fix compilation issues

diff --git a/morep_simulator.c b/morep_simulator.c
index 7bdc654a544cb828aea1bdd59d71f112d6db43b4..0528f49577842fbd2987548a8b58a3f1645ae8f1 100644 (file)
--- a/morep_simulator.c
+++ b/morep_simulator.c
@@ -71,8 +71,8 @@ typedef enum {
     key_e,
     prng_param_e,
     raw_data_e,
-    status_e
-    nopdu_e,
+    status_e,
+    nopdu_e
 } pdu_t;
 
 typedef struct {
@@ -374,19 +374,19 @@ int main (int argc, char **argv)
         int offset = 1;
 
         comm_t *comm = NULL;
-        service_t serv = NULL;
+        service_t *serv = NULL;
         /* find MOREP by service name */
         for (int i = 0; ((service_list + i)->service_id != noserv_e) && (serv == NULL); i++) {
             service_t *s = service_list + i;
             VERBOSE (morep, TRACE, PRINTF ("test %c[%s]\n", *line, s->name));
             if (strncmp (line + offset, s->name, strlen (s->name)) == 0) {
                 comm = mode ? &(s->rx) : &(s->tx);
-                serv = s->service_id;
+                serv = s;
                 offset += strlen (s->name);
             }
         }
         /* find MOREP by ethertype */
-        for (int j = 0; (j < nbcomms) && (comm == NULL); i++) {
+        for (int j = 0; (j < nbcomms) && (comm == NULL); j++) {
             comm_t *c = comm_list + j;
             VERBOSE (morep, TRACE, PRINTF ("test %c[%s]\n", c->mode ? 'T' : 'R', c->etype));
             if ((strncmp (line + offset, c->etype, strlen (c->etype)) == 0) && (c->mode == mode)) {
@@ -417,7 +417,7 @@ int main (int argc, char **argv)
         /* get message type by name */
         for (int i = 0; ((message_list + i)->service_id != noserv_e) && (msg == NULL); i++) {
             message_t *m = message_list + i;
-            VERBOSE (morep, TRACE, PRINT ("test %s\n", m->name));
+            VERBOSE (morep, TRACE, PRINTF ("test %s\n", m->name));
             if (strncmp (line + offset, m->name, strlen (m->name)) == 0) {
                 msg = m;
                 offset += strlen (m->name);
@@ -437,131 +437,137 @@ int main (int argc, char **argv)
                 VERBOSE (morep, WARNING, PRINTF ("can't parse line '%s' (%d)\n", line, offset));
                 continue;
             }
+            /* find message */
+            for (int i = 0; ((message_list + i)->service_id != noserv_e) && (msg == NULL); i++) {
+                message_t *m = message_list + i;
+                if ((m->service_id == serv->service_id) && (m->msgtype == msgtype)) {
+                    msg = m;
+                }
+            }
         }
 
         /* check message and service */ 
-        if (serv->service_id != m->service_id) {
-            VERBOSE (morep, WARNING, PRINTF ("message %s is not allowed for service %S (line '%s')\n", msg->name, serv->name, line);
+        if (serv->service_id != msg->service_id) {
+            VERBOSE (morep, WARNING, PRINTF ("message %s is not allowed for service %s (line '%s')\n", msg->name, serv->name, line));
             continue;
         }
 
-        msg_channel CHANNEL_t = {0};
-        msg_clear_data CLEAR_DATA_t = {0};
-        msg_encrypted_data ENCRYPTED_DATA_t = {0};
-        msg_key KEY_t = {0};
-        msg_prng_param PRNG_PARAM_t = {0};
-        msg_raw_data RAW_DATA_t = {0};
-        msg_status STATUS_t = {0};
+        CHANNEL_t msg_channel = {0};
+        CLEAR_DATA_t msg_clear_data = {0};
+        ENCRYPTED_DATA_t msg_encrypted_data = {0};
+        KEY_t msg_key = {0};
+        PRNG_PARAM_t msg_prng_param = {0};
+        RAW_DATA_t msg_raw_data = {0};
+        STATUS_t msg_status = {0};
         
         int seqnum = -1;
+        int len = 0;
+        pdu_t pdu;
         if (mode == 1) { /* transmit */
 
             /* parse message */
-            int rc = -1;
-            switch (serv->pdu) {
+            pdu = msg->pdu;
+            switch (pdu) {
             case channel_e:
-                rc = parse_channel (line + offset, &msg_channel);
+                parse_channel (line + offset, &msg_channel);
                 break;
             case clear_data_e:
-                rc = parse_clear_data (line + offset, &msg_clear_data);
+                parse_clear_data (line + offset, &msg_clear_data);
                 break;
             case encrypted_data_e:
-                rc = parse_encrypted_data (line + offset, &msg_encrypted_data);
+                parse_encrypted_data (line + offset, &msg_encrypted_data);
                 break;
             case key_e:
-                rc = parse_key (line + offset, &msg_key);
+                parse_key (line + offset, &msg_key);
                 break;
             case prng_param_e:
-                rc = parse_prng_param (line + offset, &msg_prng_param);
+                parse_prng_param (line + offset, &msg_prng_param);
                 break;
             case raw_data_e:
-                rc = parse_raw_data (line + offset, &msg_raw_data);
+                parse_raw_data (line + offset, &msg_raw_data);
                 break;
             case status_e:
-                rc = parse_status (line + offset, &msg_status);
+                parse_status (line + offset, &msg_status);
                 break;
-            }
-            if (rc != 0) {
+            default:
                 VERBOSE (morep, WARNING, PRINTF ("can't parse line '%s' (%d)\n", line, offset));
                 continue;
             }
 
             /* send message */
             uint8_t payload[1496] = {0};
-            int len = -1;
-            switch (serv->pdu) {
+            switch (pdu) {
             case channel_e:
-                rc = serial_channel (&msg_channel, payload, sizeof (payload));
+                len = serial_channel (&msg_channel, payload, sizeof (payload));
                 break;
             case clear_data_e:
-                rc = serial_clear_data (&msg_clear_data, payload, sizeof (payload));
+                len = serial_clear_data (&msg_clear_data, payload, sizeof (payload));
                 break;
             case encrypted_data_e:
-                rc = serial_encrypted_data (&msg_encrypted_data, payload, sizeof (payload));
+                len = serial_encrypted_data (&msg_encrypted_data, payload, sizeof (payload));
                 break;
             case key_e:
-                rc = serial_key (&msg_key, payload, sizeof (payload));
+                len = serial_key (&msg_key, payload, sizeof (payload));
                 break;
             case prng_param_e:
-                rc = serial_prng_param (&msg_prng_param, payload, sizeof (payload));
+                len = serial_prng_param (&msg_prng_param, payload, sizeof (payload));
                 break;
             case raw_data_e:
-                rc = serial_raw_data (&msg_raw_data, payload, sizeof (payload));
+                len = serial_raw_data (&msg_raw_data, payload, sizeof (payload));
                 break;
             case status_e:
-                rc = serial_status (&msg_status, payload, sizeof (payload));
+                len = serial_status (&msg_status, payload, sizeof (payload));
                 break;
+            default:
+                len = 0;
             }
             seqnum = MOREP_Send (comm->morep, msg->msgtype, payload, len);
 
         } else { /* receive */
 
-            uint8_t rxmsgtype = 0;
-            uint8_t rxpayload[1496] = {0};
-            int rxlen = -1;
-            int seqnum = MOREP_Receive (comm->morep, &rxmsgtype, rxpayload, &rxlen);
+            uint8_t msgtype = 0;
+            uint8_t payload[1496] = {0};
+            int seqnum = MOREP_Receive (comm->morep, &msgtype, payload, &len);
 
             /* check pdu type */
-            pdu_t pdu = undef_pdu_e;
-            for (int i = 0; ((message_list + i)->service_id) && (pdu == undef_e); i++) {
+            pdu = undef_pdu_e;
+            for (int i = 0; ((message_list + i)->service_id) && (pdu == undef_pdu_e); i++) {
                 message_t *m = message_list + i;
-                if ((m->service_id == serv->service_id) && (m->msgtype == rxmsgtype)) {
+                if ((m->service_id == serv->service_id) && (m->msgtype == msgtype)) {
                     pdu = m->pdu;
                 }
             }
 
             /* check msg type */
-            if (rxmsgtype != msgtype) {
-                VERBOSE (morep, WARNING, PRINTF ("R%sx SEQ=%d MSG=%d: expected msgtype %d\n", comm->etype, seqnum, rxmsgtype, msg->msgtype));
+            if (msgtype != msg->msgtype) {
+                VERBOSE (morep, WARNING, PRINTF ("R%sx SEQ=%d MSG=%d: expected msgtype %d\n", comm->etype, seqnum, msgtype, msg->msgtype));
             }
 
             /* deserialize message */
-            int rc = -1;
             switch (pdu) {
             case channel_e:
-                rc = deserial_channel (rxpayload, rxlen, &msg_channel);
+                deserial_channel (payload, len, &msg_channel);
                 break;
             case clear_data_e:
-                rc = deserial_clear_data (rxpayload, rxlen, &msg_clear_data);
+                deserial_clear_data (payload, len, &msg_clear_data);
                 break;
             case encrypted_data_e:
-                rc = deserial_encrypted_data (rxpayload, rxlen, &msg_encrypted_data);
+                deserial_encrypted_data (payload, len, &msg_encrypted_data);
                 break;
             case key_e:
-                rc = deserial_key (rxpayload, rxlen, &msg_key);
+                deserial_key (payload, len, &msg_key);
                 break;
             case prng_param_e:
-                rc = deserial_prng_param (rxpayload, rxlen, &msg_prng_param);
+                deserial_prng_param (payload, len, &msg_prng_param);
                 break;
             case raw_data_e:
-                rc = deserial_raw_data (rxpayload, rxlen, &msg_raw_data);
+                deserial_raw_data (payload, len, &msg_raw_data);
                 break;
             case status_e:
-                rc = deserial_status (rxpayload, rxlen, &msg_status);
+                deserial_status (payload, len, &msg_status);
                 break;
-            }
-            if (rc != 0) {
-                VERBOSE (morep, WARNING, PRINTF ("can't deserialize message R%s[%02x]'\n", comm->etype, rxmsgtype));
+            default:
+                VERBOSE (morep, WARNING, PRINTF ("can't deserialize message R%s[%02x]'\n", comm->etype, msgtype));
                 continue;
             }
 
@@ -570,29 +576,31 @@ int main (int argc, char **argv)
         /* log message */
         if (log) {
             fprintf (log, "%c%s[%s] SEG=%d MSG=%d LEN=%d %s ", mode ? 'T' : 'R', serv->name, comm->etype, seqnum, msg->msgtype, len, msg->name);
-            char * buffer[1496 * 3 + 256] = {0};
-            switch (serv->service_id) {
+            char buffer[1496 * 3 + 256] = {0};
+            switch (pdu) {
             case channel_e:
-                rc = serial_channel (&msg_channel, buffer, sizeof (buffer));
+                format_channel (&msg_channel, buffer, sizeof (buffer));
                 break;
             case clear_data_e:
-                rc = serial_clear_data (&msg_clear_data, buffer, sizeof (buffer));
+                format_clear_data (&msg_clear_data, buffer, sizeof (buffer));
                 break;
             case encrypted_data_e:
-                rc = serial_encrypted_data (&msg_encrypted_data, buffer, sizeof (buffer));
+                format_encrypted_data (&msg_encrypted_data, buffer, sizeof (buffer));
                 break;
             case key_e:
-                rc = serial_key (&msg_key, buffer, sizeof (buffer));
+                format_key (&msg_key, buffer, sizeof (buffer));
                 break;
             case prng_param_e:
-                rc = serial_prng_param (&msg_prng_param, buffer, sizeof (buffer));
+                format_prng_param (&msg_prng_param, buffer, sizeof (buffer));
                 break;
             case raw_data_e:
-                rc = serial_raw_data (&msg_raw_data, buffer, sizeof (buffer));
+                format_raw_data (&msg_raw_data, buffer, sizeof (buffer));
                 break;
             case status_e:
-                rc = serial_status (&msg_status, buffer, sizeof (buffer));
+                format_status (&msg_status, buffer, sizeof (buffer));
                 break;
+            default:
+                snprintf (buffer, sizeof (buffer), "unknown payload");
             }
             fprintf (log, "%s\n", buffer);
         }