Message chart generator (mscgen)

git-svn-id: http://svn.eurecom.fr/openair4G/trunk@6963 818b1a75-f10b-46b9-bf7c-635c3b92a50f

common/utils/msc/msc.c

+/*******************************************************************************
+    OpenAirInterface
+    Copyright(c) 1999 - 2014 Eurecom
+
+    OpenAirInterface is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+
+    OpenAirInterface is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenAirInterface.The full GNU General Public License is
+   included in this distribution in the file called "COPYING". If not,
+   see <http://www.gnu.org/licenses/>.
+
+  Contact Information
+  OpenAirInterface Admin: openair_admin@eurecom.fr
+  OpenAirInterface Tech : openair_tech@eurecom.fr
+  OpenAirInterface Dev  : openair4g-devel@eurecom.fr
+
+  Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
+
+ *******************************************************************************/
+/*! \file msc.c
+ * \brief Message chart generator logging utility (generated files to processed by a scrip to produce a mscgen input file for generating a sequence diagram document)
+ * \author  Lionel GAUTHIER
+ * \date 2015
+ * \email: lionel.gauthier@eurecom.fr
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include "msc.h"
+//-------------------------------
+#define MSC_MAX_PROTO_NAME_LENGTH 16
+//-------------------------------
+
+FILE*    msc_fd[MAX_MSC_PROTOS]; // may need to split in more files to avoid overwrites (want to avoid mutexes)
+char     msc_proto2str[MAX_MSC_PROTOS][MSC_MAX_PROTO_NAME_LENGTH];
+uint64_t msc_event_counter = 0;
+
+//------------------------------------------------------------------------------
+int msc_init(void)
+//------------------------------------------------------------------------------
+{
+  int i;
+  int rv;
+
+  for (i = MIN_MSC_PROTOS; i < MAX_MSC_PROTOS; i++) {
+      switch (i) {
+        case MSC_NAS_UE:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "NAS_UE");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.nas_ue.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_RRC_UE:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "RRC_UE");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.rrc_ue.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_PDCP_UE:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "PDCP_UE");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.pdcp_ue.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_RLC_UE:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "RLC_UE");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.rlc_ue.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_MAC_UE:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "MAC_UE");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.mac_ue.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_PHY_UE:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "PHY_UE");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.phy_ue.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_PHY_ENB:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "PHY_ENB");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.phy_enb.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_MAC_ENB:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "MAC_ENB");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.mac_enb.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_RLC_ENB:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "RLC_ENB");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.rlc_enb.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_PDCP_ENB:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "PDCP_ENB");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.pdcp_enb.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_RRC_ENB:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "RRC_ENB");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.rrc_enb.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_S1AP_ENB:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "S1AP_ENB");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.s1ap_enb.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_GTPU_ENB:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "GTPU_ENB");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = fopen("/tmp/openair.msc.gtpu_enb.log","w");
+          msc_log_declare_proto(i);
+          break;
+        case MSC_GTPU_SGW:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "GTPU_SGW");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = NULL;
+          break;
+        case MSC_S1AP_MME:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "S1AP_MME");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = NULL;
+          break;
+        case MSC_NAS_MME:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "NAS_MME");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = NULL;
+          break;
+        default:
+          rv = snprintf(&msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "UNKNOWN");
+          if (rv >= MSC_MAX_PROTO_NAME_LENGTH) {msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH-1] = 0;}
+          msc_fd[i] = NULL;
+      }
+  }
+  return 0;
+}
+
+
+//------------------------------------------------------------------------------
+void msc_end(void)
+//------------------------------------------------------------------------------
+{
+  int rv;
+  int i;
+  for (i = MIN_MSC_PROTOS; i < MAX_MSC_PROTOS; i++) {
+      rv = fflush(msc_fd[i]);
+      if (rv != 0) {
+          fprintf(stderr, "Error while flushing stream of MSC log file: %s", strerror(errno));
+      }
+      rv = fclose(msc_fd[i]);
+      if (rv != 0) {
+          fprintf(stderr, "Error while closing MSC log file: %s", strerror(errno));
+      }
+  }
+}
+
+//------------------------------------------------------------------------------
+void msc_log_declare_proto(
+    const msc_proto_t  protoP
+  )
+//------------------------------------------------------------------------------
+{
+  int rv;
+  uint64_t local_msc_event_counter = msc_event_counter;
+  msc_event_counter++;
+  if ((protoP >= MIN_MSC_PROTOS) && (protoP < MAX_MSC_PROTOS)) {
+      rv = fprintf(msc_fd[protoP], "%"PRIu64" [PROTO] %d %s\n", local_msc_event_counter, protoP, &msc_proto2str[protoP][0]);
+      if (rv < 0) {
+          fprintf(stderr, "Error while declaring new protocol in MSC log file: %s", strerror(errno));
+      }
+  }
+}
+//------------------------------------------------------------------------------
+void msc_log_event(
+    const msc_proto_t  protoP,
+    char *format, ...)
+//------------------------------------------------------------------------------
+{
+  va_list    args;
+  int        rv;
+  uint64_t local_msc_event_counter = msc_event_counter;
+
+  msc_event_counter++;
+
+  if ((protoP < MIN_MSC_PROTOS) || (protoP >= MAX_MSC_PROTOS)) {
+      return;
+  }
+  if (msc_fd != NULL) {
+      rv = fprintf(msc_fd[protoP], "%"PRIu64" [EVENT] %d ", local_msc_event_counter, protoP);
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC event : %s", &msc_proto2str[protoP][0]);
+      }
+      va_start(args, format);
+      rv = vfprintf(msc_fd[protoP], format, args);
+      va_end(args);
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC event : %s", &msc_proto2str[protoP][0]);
+      }
+      rv = fprintf(msc_fd[protoP], "\n");
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC event : %s", &msc_proto2str[protoP][0]);
+      }
+  }
+}
+//------------------------------------------------------------------------------
+void msc_log_rx_message(
+    const msc_proto_t  receiverP,
+    const msc_proto_t  senderP,
+    const char*        bytesP,
+    const unsigned int num_bytes,
+    char *format, ...)
+//------------------------------------------------------------------------------
+{
+  va_list    args;
+  int        rv;
+  uint64_t   mac = 0;
+  uint64_t local_msc_event_counter = msc_event_counter;
+
+  msc_event_counter++;
+
+  if ((receiverP < MIN_MSC_PROTOS) || (receiverP >= MAX_MSC_PROTOS) ||
+      (senderP < MIN_MSC_PROTOS)   || (senderP >= MAX_MSC_PROTOS)) {
+      return;
+  }
+  if (msc_fd[receiverP] != NULL) {
+      rv = fprintf(msc_fd[receiverP], "%"PRIu64" [MESSAGE] %d <- %d %"PRIu64" ",
+                   local_msc_event_counter, receiverP, senderP, mac);
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC RX message : %s", &msc_proto2str[receiverP][0]);
+      }
+      va_start(args, format);
+      rv = vfprintf(msc_fd[receiverP], format, args);
+      va_end(args);
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC RX message : %s", &msc_proto2str[receiverP][0]);
+      }
+      rv = fprintf(msc_fd[receiverP], "\n");
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC RX message : %s", &msc_proto2str[receiverP][0]);
+      }
+      if ((msc_event_counter & 0x000000000000000F) == 0x000000000000000F) {
+          fflush(msc_fd[receiverP]);
+      }
+  }
+}
+//------------------------------------------------------------------------------
+void msc_log_rx_discarded_message(
+    const msc_proto_t  receiverP,
+    const msc_proto_t  senderP,
+    const char*        bytesP,
+    const unsigned int num_bytes,
+    char *format, ...)
+//------------------------------------------------------------------------------
+{
+  va_list    args;
+  int        rv;
+  uint64_t   mac = 0;
+  uint64_t local_msc_event_counter = msc_event_counter;
+
+  msc_event_counter++;
+
+  if ((receiverP < MIN_MSC_PROTOS) || (receiverP >= MAX_MSC_PROTOS) ||
+      (senderP < MIN_MSC_PROTOS)   || (senderP >= MAX_MSC_PROTOS)) {
+      return;
+  }
+  if (msc_fd[receiverP] != NULL) {
+      rv = fprintf(msc_fd[receiverP], "%"PRIu64" [MESSAGE] %d x- %d %"PRIu64" ",
+                   local_msc_event_counter, receiverP, senderP, mac);
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC RX message : %s", &msc_proto2str[receiverP][0]);
+      }
+      va_start(args, format);
+      rv = vfprintf(msc_fd[receiverP], format, args);
+      va_end(args);
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC RX message : %s", &msc_proto2str[receiverP][0]);
+      }
+      rv = fprintf(msc_fd[receiverP], "\n");
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC RX message : %s", &msc_proto2str[receiverP][0]);
+      }
+      if ((msc_event_counter & 0x000000000000000F) == 0x000000000000000F) {
+          fflush(msc_fd[receiverP]);
+      }
+  }
+}
+//------------------------------------------------------------------------------
+void msc_log_tx_message(
+    const msc_proto_t  senderP,
+    const msc_proto_t  receiverP,
+    const char*        bytesP,
+    const unsigned int num_bytes,
+    char *format, ...)
+//------------------------------------------------------------------------------
+{
+  va_list    args;
+  int        rv;
+  uint64_t   mac = 0;
+  uint64_t   local_msc_event_counter = msc_event_counter;
+
+  msc_event_counter++;
+
+  if ((receiverP < MIN_MSC_PROTOS) || (receiverP >= MAX_MSC_PROTOS) ||
+      (senderP < MIN_MSC_PROTOS)   || (senderP >= MAX_MSC_PROTOS)) {
+      return;
+  }
+  if (msc_fd[senderP] != NULL) {
+      rv = fprintf(msc_fd[senderP], "%"PRIu64" [MESSAGE] %d -> %d %"PRIu64" ",
+                   local_msc_event_counter, senderP, receiverP, mac);
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC TX message : %s", &msc_proto2str[senderP][0]);
+      }
+      va_start(args, format);
+      rv = vfprintf(msc_fd[senderP], format, args);
+      va_end(args);
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC TX message : %s", &msc_proto2str[senderP][0]);
+      }
+      rv = fprintf(msc_fd[senderP], "\n");
+      if (rv < 0) {
+         fprintf(stderr, "Error while logging MSC TX message : %s", &msc_proto2str[senderP][0]);
+      }
+      if ((msc_event_counter & 0x000000000000000F) == 0x000000000000000F) {
+          fflush(msc_fd[senderP]);
+      }
+  }
+}
+
+

common/utils/msc/msc.h

+/*******************************************************************************
+    OpenAirInterface
+    Copyright(c) 1999 - 2014 Eurecom
+
+    OpenAirInterface is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+
+    OpenAirInterface is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenAirInterface.The full GNU General Public License is
+   included in this distribution in the file called "COPYING". If not,
+   see <http://www.gnu.org/licenses/>.
+
+  Contact Information
+  OpenAirInterface Admin: openair_admin@eurecom.fr
+  OpenAirInterface Tech : openair_tech@eurecom.fr
+  OpenAirInterface Dev  : openair4g-devel@eurecom.fr
+
+  Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
+
+ *******************************************************************************/
+
+#ifndef MSC_H_
+#define MSC_H_
+#include <stdarg.h>
+
+typedef enum {
+    MIN_MSC_PROTOS = 0,
+    MSC_NAS_UE = MIN_MSC_PROTOS,
+    MSC_RRC_UE,
+    MSC_PDCP_UE,
+    MSC_RLC_UE,
+    MSC_MAC_UE,
+    MSC_PHY_UE,
+    MSC_PHY_ENB,
+    MSC_MAC_ENB,
+    MSC_RLC_ENB,
+    MSC_PDCP_ENB,
+    MSC_RRC_ENB,
+    MSC_S1AP_ENB,
+    MSC_GTPU_ENB,
+    MSC_GTPU_SGW,
+    MSC_S1AP_MME,
+    MSC_NAS_MME,
+    MSC_S6A_MME,
+    MSC_HSS,
+    MAX_MSC_PROTOS,
+} msc_proto_t;
+
+// Access stratum
+#define MSC_AS_TIME_FMT "%05u:%02u"
+
+#define MSC_AS_TIME_ARGS(CTXT_Pp) \
+    (CTXT_Pp)->frame, \
+    (CTXT_Pp)->subframe
+
+int msc_init(void);
+void msc_end(void);
+void msc_log_declare_proto(const msc_proto_t  protoP);
+void msc_log_event(const msc_proto_t  protoP,char *format, ...);
+void msc_log_rx_message(
+    const msc_proto_t  receiverP,
+    const msc_proto_t  senderP,
+    const char*        bytesP,
+    const unsigned int num_bytes,
+    char *format, ...);
+void msc_log_rx_discarded_message(
+    const msc_proto_t  receiverP,
+    const msc_proto_t  senderP,
+    const char*        bytesP,
+    const unsigned int num_bytes,
+    char *format, ...);
+void msc_log_tx_message(
+    const msc_proto_t  senderP,
+    const msc_proto_t  receiverP,
+    const char*        bytesP,
+    const unsigned int num_bytes,
+    char *format, ...);
+
+#endif