masterthesis-ecdaa-network-wrapper/verifier.c

#include "verifier.h"

typedef enum verifierstate {
    ON,
    ASKISSUER,
    GOTISSUER,
    ASKMEMBER,
    GOTMEMBER
} verifierstate_e;

typedef struct verifier {
    struct ecdaa_verifier_public_key_FP256BN mpk;
    struct ecdaa_verifier_public_key_FP256BN ipk;
    verifierstate_e state;
} verifier_t;

verifier_t verifier;

int verifier_getissuer(char *buffer);

int verifier_getmember(char *buffer);

int main() {
    int err = 0;

    if (2 != server_start(&process_verifier, VERIFIERPORT)) {
        printf("server failed\n");
    }
    return 0;
}

int process_verifier(char *buffer) {
    int ret = 0;

    printf("> VERIFIER: %s\n", buffer);

    if (0 == strncasecmp("VERIFY", buffer, 6)) {
        switch (verifier.state) {
            case GOTMEMBER:
                printf("verify()\n");
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "OK\n", 3);
                break;
            default:
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
        }
    } else if (0 == strncasecmp("LINk", buffer, 4)) {
        printf("getpublished()\n");
        bzero(buffer, MAX_BUFSIZE);
        strncpy(buffer, "OK\n", 3);
    } else if (0 == strncasecmp("GETPUBLISHED", buffer, 12)) {
        printf("link()\n");
        verifier.state = ON;
        ret = client_connect(&verifier_getissuer, ISSUERIP, ISSUERPORT);
        if (0 >= ret || GOTISSUER != verifier.state) {
            printf("process_verifier: issuer connection failed\n");
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "ERR\n", 4);
        } else {
            ret = client_connect(&verifier_getmember, MEMBERIP, MEMBERPORT);
            if (0 >= ret || GOTMEMBER != verifier.state) {
                printf("process_verifier: issuer connection failed\n");
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
            } else {
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "OK\n", 3);
            }
            ret = 0;
        }
    } else if (0 == strncasecmp("EXIT", buffer, 4)) {
        printf("exit()\n");
        bzero(buffer, MAX_BUFSIZE);
        strncpy(buffer, "OK\n", 3);
        ret = 1;
    } else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) {
        bzero(buffer, MAX_BUFSIZE);
        strncpy(buffer, "OK\n", 3);
        ret = 2;
    } else {
        printf("error()\n");
        bzero(buffer, MAX_BUFSIZE);
        strncpy(buffer, "ERR\n", 4);
        ret = 0;
    }

    printf("< VERIFIER: %s\n", buffer);
    return ret;
}

int verifier_getissuer(char *buffer) {
    int ret = 0;

    printf("ISSUER > VERIFIER: %s", buffer);
    switch (verifier.state) {
        case ON:
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "PUBLISH\n", 8);
            verifier.state = ASKISSUER;
            break;
        case ASKISSUER:
            if (0 == strncasecmp("PUBLISH", buffer, 7)) {
                bzero(buffer, MAX_BUFSIZE);
                verifier.state = GOTISSUER;
                ret = 1;
            }
            break;
        default:
            ret - 1;
    }
    if (0 == ret) {
        printf("ISSUER < VERIFIER: %s", buffer);
    }
    return ret;
}

int verifier_getmember(char *buffer) {
    int ret = 0;

    printf("ISSUER > VERIFIER: %s", buffer);
    switch (verifier.state) {
        case ON:
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "PUBLISH\n", 8);
            verifier.state = ASKMEMBER;
            break;
        case ASKMEMBER:
            if (0 == strncasecmp("PUBLISH", buffer, 7)) {
                bzero(buffer, MAX_BUFSIZE);
                verifier.state = GOTMEMBER;
                ret = 1;
            }
            break;
        default:
            ret - 1;
    }
    if (0 == ret) {
        printf("ISSUER < VERIFIER: %s", buffer);
    }
    return ret;
}