src/rlog/rl_postproc.cpp

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /********************************************************************20**
  20
  21      Name:     Radisys Logging Framework
  22      Type:     C++ source file
  23      Desc:     This file contains logging framework implementation.
  24      File:     postproc.cpp
  25
  26 *********************************************************************21*/
  27 ///////////////////////////////////////////////////////////////////////////////
  28 // @ description: This is source file  contains the implementaion of binary log
  29 // postprocessor and has ability to connect to remote node and print live logs.
  30 ///////////////////////////////////////////////////////////////////////////////
  31
  32 #include <iostream>
  33 #include <fstream>
  34 #include <string>
  35 #include <sstream>
  36 #include <map>
  37 #include <list>
  38 #include <algorithm>
  39 #include <unistd.h>
  40 #include <pthread.h>
  41 #include <sys/socket.h>
  42 #include <netinet/in.h>
  43 #include <getopt.h>
  44 #include <stdarg.h>
  45 #include <arpa/inet.h>
  46 #include <fcntl.h>
  47 #include <string.h>
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <netdb.h>
  51 #include <sys/types.h>
  52 #include <arpa/inet.h>
  53 #include "rl_interface.h"
  54 #include "rl_rlog.h"
  55
  56 #define TEST_MODE
  57
  58 namespace cmdlinearg {
  59 int g_port = 0;
  60 std::string g_sFileDb;  /* File DB */
  61 std::string g_sLogDb;   /* Log DB */
  62 std::string g_sOutFile; /* Output file */
  63 std::string g_sBinLogFile; /* Input binary log file */
  64 std::string g_ipAddr;
  65 }
  66
  67 typedef struct
  68 {
  69   int lineno;
  70   std::string modName;
  71   std::string file;
  72   std::string logStr;
  73
  74 } LOG_INFO;
  75
  76 static struct option long_options[] =
  77 {
  78    {"port",   required_argument,   0, 'p'},
  79    {"logdb",   required_argument,   0, 'l'},
  80    {"ofile",  required_argument,   0, 'o'},
  81    {"blog",   required_argument,   0, 'b'},
  82    {"ipaddr",   required_argument,   0, 'i'},
  83    {0, 0, 0, 0}
  84 };
  85
  86 std::map<unsigned short, std::string> g_mFileInfo;
  87 std::map<LOGID, LOG_INFO> g_mLogInfo;
  88 FILE* g_fp=stderr;
  89 U32 g_ttiCount = 0;
  90 time_t g_basetimeSec;
  91
  92 void readCmdLineArgs(int argc,char **argv);
  93 void printLogTime(LOGTIME & ltime);
  94 void loadLogDb();
  95 void printUsage();
  96 void logHexDump(ARGDATA & log);
  97 bool invalidLogId(LOGID logId);
  98 void openLogFile(const char* file);
  99 void logLevN(LOGDATA & log, LOG_INFO & logInfo, const char* fmtStr, ...);
 100 void logLevS(LOGDATA & log, LOG_INFO & logInfo, const char* fmtStr, const char *logStr);
 101 void logString(ARGDATA & log);
 102 void logIntArg(ARG4DATA* log);
 103 void logArgSpl(SPL_ARGDATA* log);
 104 void processLogs(int fd, bool (*fpReadLog)(int, ARGDATA &));
 105
 106 bool readRemoteLogs(int sockfd, ARGDATA & log);
 107 bool readFileLogs(int fd, ARGDATA & log);
 108 int openBinLogFile();
 109 int connectToLogServer();
 110
 111 ///////////////////////////////////////////////////////////////////////////////////////////////////
 112 // @arg[in] argc  - Number of arguments
 113 // @arg[in] argv - Command line arguments
 114 // This is main functions, which calls a function to parse command line arguments. Then it loads
 115 // log metadata into memory. And then based on if its remote logging or binary log file parsing
 116 // passes apropriate function pointer to read and convert logs.
 117 ///////////////////////////////////////////////////////////////////////////////////////////////////
 118 int main(int argc, char* argv[])
 119 {
 120   readCmdLineArgs(argc, argv);
 121   loadLogDb();
 122
 123   if( !cmdlinearg::g_sBinLogFile.empty() )
 124   {
 125     if( !cmdlinearg::g_sOutFile.empty() )
 126     {
 127       openLogFile(cmdlinearg::g_sOutFile.c_str());
 128
 129       processLogs(openBinLogFile(), readFileLogs);
 130       fclose(g_fp);
 131     }
 132   }
 133
 134   if( cmdlinearg::g_port != 0 ) {
 135
 136     if( !cmdlinearg::g_sOutFile.empty() ) {
 137       openLogFile(cmdlinearg::g_sOutFile.c_str());
 138     }
 139
 140
 141     processLogs(connectToLogServer(), readRemoteLogs);
 142
 143     fclose(g_fp);
 144   }
 145    return 0;
 146 }
 147
 148 ///////////////////////////////////////////////////////////////////////////////////////////////////
 149 // @param[in] file - Input log file name
 150 // This function opens the log file in write mode.
 151 ///////////////////////////////////////////////////////////////////////////////////////////////////
 152 void openLogFile(const char* file)
 153 {
 154    g_fp = fopen(file, "w+");
 155
 156   if( g_fp == NULL )
 157   {
 158       fprintf(stderr, "Failed to open log file %s\n", file);
 159       _exit(0);
 160    }
 161
 162    fprintf(stderr, "Log Output will be written in %s\n", file);
 163 }
 164
 165 uint32_t swap_uint32( uint32_t val )
 166 {
 167     val = ((val << 8) & 0xFF00FF00 ) | ((val >> 8) & 0xFF00FF );
 168     return (val << 16) | (val >> 16);
 169 }
 170
 171
 172 unsigned long EndianSwap32(unsigned long x)
 173 {
 174     unsigned long y=0;
 175     y += (x & 0x000000FF)<<24;
 176     y += (x & 0xFF000000)>>24;
 177     y += (x & 0x0000FF00)<<8;
 178     y += (x & 0x00FF0000)>>8;
 179     return y;
 180 }
 181
 182 void print_hex(const char* str, const U8 *p, int len)
 183 {
 184   fprintf(stderr, "%s HEX \n", str);
 185   for(int i=0; i<len; i++ ) fprintf(stderr, "%d ", p[i]);
 186   fprintf(stderr, "\n");
 187
 188 }
 189
 190 ///////////////////////////////////////////////////////////////////////////////////////////////////
 191 // This function open the log file in binary mode and checks if file header is correct or not.
 192 // It also sets the environment variable for given time zone in log file, so that time information
 193 // is converted to correct time zone times.
 194 ///////////////////////////////////////////////////////////////////////////////////////////////////
 195 int openBinLogFile()
 196 {
 197   int fd = open(cmdlinearg::g_sBinLogFile.c_str(), O_RDONLY );
 198
 199   if( fd == -1) {
 200       fprintf(stderr, "Failed to open log file %s\n", cmdlinearg::g_sBinLogFile.c_str());
 201     _exit(0);
 202   }
 203
 204   FILE_HEADER fileHdr;
 205
 206   int len = read(fd, (void*)&fileHdr, sizeof(FILE_HEADER));
 207
 208   if( fileHdr.END_MARKER != 0xFFFF ) {
 209     fprintf(stderr, "Invalid file header\n");
 210     _exit(0);
 211   }
 212
 213   fprintf(stderr, "FILE ENDIAN: %s\n", fileHdr.endianType == big_endian ? "BIG ENDIAN" : "LITTLE ENDIAN");
 214   fprintf(stderr, "TIME ZONE: %s\n", fileHdr.szTimeZone);
 215
 216   setenv("TZ", fileHdr.szTimeZone, 1);
 217   tzset();
 218
 219   if( fileHdr.endianType == big_endian ) {
 220   }
 221   g_basetimeSec = fileHdr.time_sec;
 222   return fd;
 223 }
 224
 225 ///////////////////////////////////////////////////////////////////////////////////////////////////
 226 // This function connects to remote application which is using binary logging framework. If
 227 // connection is failed log application exits.
 228 ///////////////////////////////////////////////////////////////////////////////////////////////////
 229 int connectToLogServer()
 230 {
 231   int sockfd;
 232   struct addrinfo hints;
 233   struct addrinfo *res = NULL;
 234   struct addrinfo *result = NULL;
 235   int errcode;
 236   char addrstr[100];
 237   void *ptr = NULL;
 238   struct sockaddr_in serv_addr;
 239   struct sockaddr_in6 serv_addr6;
 240   void *sockServAddr = NULL;
 241   int ai_family = AF_UNSPEC;
 242   int size = 0;
 243
 244   /* ccpu00147898 fixes */
 245   memset(&hints, 0, sizeof(hints));
 246   memset((void*)&serv_addr, 0, sizeof(serv_addr));
 247   memset((void*)&serv_addr6, 0, sizeof(serv_addr6));
 248   hints.ai_family = PF_UNSPEC;
 249   hints.ai_socktype = SOCK_STREAM;
 250   hints.ai_flags |= AI_CANONNAME;
 251
 252   errcode = getaddrinfo(cmdlinearg::g_ipAddr.c_str(), NULL, &hints, &res);
 253   if(errcode != 0)
 254   {
 255     perror ("getaddrinfo");
 256     return -1;
 257   }
 258
 259   result = res;
 260   while(res)
 261   {
 262     inet_ntop(res->ai_family, res->ai_addr->sa_data, addrstr, 100);
 263
 264     switch(res->ai_family)
 265     {
 266       case AF_INET:
 267         ptr = &((struct sockaddr_in *) res->ai_addr)->sin_addr;
 268         serv_addr.sin_addr = ((struct sockaddr_in *) res->ai_addr)->sin_addr;
 269         sockServAddr = &serv_addr;
 270         ai_family = res->ai_family;
 271         serv_addr.sin_family = res->ai_family;
 272         serv_addr.sin_port = htons(cmdlinearg::g_port);
 273         size =  sizeof(serv_addr);
 274         break;
 275       case AF_INET6:
 276         ptr = &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr;
 277         sockServAddr = &serv_addr6;
 278         /* Copy IPv6 address(16bytes) into the destination */
 279         memcpy((unsigned char*)serv_addr6.sin6_addr.s6_addr, (unsigned char *)
 280          &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr, 16);
 281         ai_family = res->ai_family;
 282         serv_addr6.sin6_family = res->ai_family;
 283         serv_addr6.sin6_port = htons(cmdlinearg::g_port);
 284         size =  sizeof(serv_addr6);
 285         break;
 286       default:
 287         sockServAddr = NULL;
 288         break;
 289     }
 290
 291     if(ptr != NULL)
 292     {
 293        inet_ntop(res->ai_family, ptr, addrstr, 100);
 294        printf ("IPv%d address: %s (%s)\n", res->ai_family == PF_INET6 ? 6 : 4,
 295              addrstr, res->ai_canonname);
 296     }
 297     res = res->ai_next;
 298   }
 299
 300   if(sockServAddr == NULL || size == 0)
 301   {
 302      fprintf(stderr, "Not able to parse server address\n");
 303      _exit(0);
 304   }
 305
 306   if( (sockfd = socket(ai_family, SOCK_STREAM,0)) < 0 ) {
 307     fprintf(stderr, "Failed to create socket\n");
 308     _exit(0);
 309   }
 310
 311   if( connect(sockfd, (const sockaddr*)sockServAddr, size) < 0 ) {
 312     perror("ERROR Connecting");
 313     _exit(0);
 314   }
 315
 316   if(result != NULL)
 317   {
 318     freeaddrinfo(result);
 319   }
 320   return sockfd;
 321 }
 322
 323 ///////////////////////////////////////////////////////////////////////////////////////////////////
 324 // @param[in] sockfd - Socket file descriptor
 325 // @paramp[in] log  - Log data buffer
 326 // This function reads the log header and remaining log from socket descriptor. Will return false
 327 // if socket operation fails.
 328 ///////////////////////////////////////////////////////////////////////////////////////////////////
 329 bool readRemoteLogs(int sockfd, ARGDATA & log)
 330 {
 331   int len;
 332
 333   while( (len = recv(sockfd, (void*)&log.logData, RLOG_FIXED_LENGTH_BUFFER_SIZE, MSG_WAITALL)) == 0 );
 334   if( len < 0 ) {
 335     return false;
 336   }
 337
 338
 339   return true;
 340 }
 341
 342 ///////////////////////////////////////////////////////////////////////////////////////////////////
 343 // @param[in] fd - input file descriptor
 344 // @param[out] log - Log header
 345 // This function will read the log header and returns success if able to read.
 346 ///////////////////////////////////////////////////////////////////////////////////////////////////
 347 bool readFileLogs(int fd, ARGDATA & log)
 348 {
 349   int len = read(fd, (void*)&log.logData, sizeof(LOGDATA));
 350
 351   if( len <= 0 ) {
 352     return false;
 353   }
 354
 355 #ifdef RLOG_MULTI_CIRCULAR_BUFFER
 356   if( log.logData.len && read(fd, (void*)log.buf, log.logData.len) <= 0 ) {
 357     return false;
 358   }
 359 #else
 360    U16 size = RLOG_FIXED_LENGTH_BUFFER_SIZE - sizeof(LOGDATA);
 361 //  if( log.logData.len && read(fd, (void*)log.buf, size) <= 0 ) {
 362   if( read(fd, (void*)log.buf, size) <= 0 ) {
 363     return false;
 364   }
 365 #endif
 366
 367   return true;
 368 }
 369
 370 ///////////////////////////////////////////////////////////////////////////////////////////////////
 371 // @param[in] log1 - LOG
 372 // @param[in] log2 - Second Log
 373 // This function compares the TTI of two consecutive logs.
 374 ///////////////////////////////////////////////////////////////////////////////////////////////////
 375 bool cmp_tti(ARGDATA & log1, ARGDATA & log2)
 376 {
 377   return log2.logData.logTime.ms_tti > log1.logData.logTime.ms_tti ? true : false;
 378 }
 379
 380 ///////////////////////////////////////////////////////////////////////////////////////////////////
 381 // @param[in] log - Log data
 382 // This function calculates the time based on TTI & time reference associated with it. And thne
 383 // calls the function to print logs in aprpriate text format.
 384 ///////////////////////////////////////////////////////////////////////////////////////////////////
 385 void printLog(ARGDATA & log)
 386 {
 387
 388   if( invalidLogId(log.logData.logId) )
 389     return;
 390
 391   switch( log.logData.argType )
 392   {
 393     case LOG_ARG_INT:
 394       logIntArg((ARG4DATA*)&log);
 395       break;
 396
 397     case  LOG_ARG_STR:
 398       logString(log);
 399       break;
 400
 401     case LOG_ARG_HEX:
 402       logHexDump(log);
 403       break;
 404
 405     case LOG_ARG_SPL:
 406       logArgSpl((SPL_ARGDATA*)&log);
 407       break;
 408   }
 409 }
 410
 411 ///////////////////////////////////////////////////////////////////////////////////////////////////
 412 // @param[in] fd - File or socket descriptor
 413 // @param[in] fpReadLog - Function pointer which reads either file or socket based log
 414 // This function reads the binary log file and does sorting of logs based on TTI and then calls the
 415 // function to print it
 416 ///////////////////////////////////////////////////////////////////////////////////////////////////
 417 void processLogs(int fd, bool (*fpReadLog)(int, ARGDATA &))
 418 {
 419   ARGDATA log;
 420   bool bSortingRequired = false, bStartBuffering = false;
 421   std::list<ARGDATA> logList;
 422
 423   while((*fpReadLog)(fd, log))
 424   {
 425     if( log.logData.logId == L_TIME_DELIMITER )
 426     {
 427       bStartBuffering = (bStartBuffering == false) ? true : false;
 428       if( bStartBuffering == true ) {
 429         bSortingRequired = true;
 430         continue;
 431       }
 432     }
 433
 434     if( bStartBuffering ) {
 435       logList.push_back(log);
 436       continue;
 437     }
 438
 439     if( bSortingRequired ) {
 440       logList.sort(cmp_tti);
 441       std::for_each(logList.begin(), logList.end(), printLog);
 442       logList.clear();
 443       bSortingRequired = false;
 444       bStartBuffering = false;
 445       continue;
 446     }
 447
 448     printLog(log);
 449   }
 450
 451   /* connection was closed due to some error, but we still have some logs */
 452   if( bStartBuffering && !logList.empty() )
 453   {
 454     logList.sort(cmp_tti);
 455     std::for_each(logList.begin(), logList.end(), printLog);
 456   }
 457
 458   close(fd);
 459 }
 460
 461
 462 ///////////////////////////////////////////////////////////////////////////////////////////////////
 463 // @param[in] log - LOG Data
 464 // This function convert binary log with integer data type into text format.
 465 ///////////////////////////////////////////////////////////////////////////////////////////////////
 466 void logIntArg(ARG4DATA* log)
 467 {
 468 #ifdef TEST_MODE
 469 //  printf("LOG ARG: INT, LEVEL: %s\n", g_logStr[log->logData.logLevel]);
 470 #endif
 471
 472   LOG_INFO & logInfo = g_mLogInfo[log->logData.logId];
 473   logLevN(log->logData,logInfo,logInfo.logStr.c_str(),log->arg1,log->arg2,log->arg3,log->arg4);
 474 }
 475
 476 ///////////////////////////////////////////////////////////////////////////////////////////////////
 477 // @param[in] log - LOG Data
 478 // This function converts binary log containg string into text format.
 479 ///////////////////////////////////////////////////////////////////////////////////////////////////
 480 void logString(ARGDATA & log)
 481 {
 482 #ifdef TEST_MODE
 483 //  printf("LOG ID %ld LOG ARG STRING, LEVEL: %s\n", log.logData.logId, g_logStr[log.logData.logLevel]);
 484 #endif
 485
 486   LOG_INFO & logInfo = g_mLogInfo[log.logData.logId];
 487   logLevS(log.logData, logInfo, logInfo.logStr.c_str(), log.buf);
 488 }
 489
 490 ///////////////////////////////////////////////////////////////////////////////////////////////////
 491 // @param[in] log - LOG Data
 492 // This function converts binary log containg hex dump into readable text format.
 493 ///////////////////////////////////////////////////////////////////////////////////////////////////
 494 void logHexDump(ARGDATA & log)
 495 {
 496 #ifdef TEST_MODE
 497 //  printf("LOG ARG HEX, LEVEL: %s\n", g_logStr[log.logData.logLevel]);
 498 #endif
 499
 500   LOG_INFO & logInfo = g_mLogInfo[log.logData.logId];
 501
 502   char szHex[MAX_LOG_BUF_SIZE*3];
 503    hextostr(szHex, log.buf, log.logData.len);
 504
 505   logLevN(log.logData, logInfo, logInfo.logStr.c_str(), szHex);
 506 }
 507
 508 ///////////////////////////////////////////////////////////////////////////////////////////////////
 509 // @param[in] log - LOG Data
 510 // @param[in] logInfo - Log information structure reference
 511 // @param[in] fmtStr - Formatted string
 512 // This function prints log into console or log file.
 513 ///////////////////////////////////////////////////////////////////////////////////////////////////
 514 void logLevN(LOGDATA & log, LOG_INFO & logInfo, const char* fmtStr, ...)
 515 {
 516    va_list argList;
 517   const char* file = logInfo.file.c_str();
 518
 519   printLogTime(log.logTime);
 520    fprintf(g_fp, "[%s]%s:%d\n%s:", logInfo.modName.c_str(), file, logInfo.lineno, g_logStr[log.logLevel]);
 521
 522    va_start(argList,fmtStr);
 523    vfprintf(g_fp, fmtStr, argList);
 524    va_end(argList);
 525 }
 526
 527 ///////////////////////////////////////////////////////////////////////////////////////////////////
 528 // @param[in] log - LOG Data
 529 // @param[in] logInfo - Log information structure reference
 530 // @param[in] fmtStr - Formatted string
 531 // This function prints string log into console or log file.
 532 ///////////////////////////////////////////////////////////////////////////////////////////////////
 533 void logLevS(LOGDATA & log, LOG_INFO & logInfo, const char* fmtStr, const char* logStr)
 534 {
 535    const char* file = logInfo.file.c_str();
 536    std::string argStr(logStr, log.len);
 537    printLogTime(log.logTime);
 538    fprintf(g_fp, "[%s]%s:%d\n%s:", logInfo.modName.c_str(), file, logInfo.lineno, g_logStr[log.logLevel]);
 539    fprintf(g_fp, fmtStr, argStr.c_str());
 540 }
 541
 542 ///////////////////////////////////////////////////////////////////////////////////////////////////
 543 // @param[in] log - LOG Data
 544 // @param[in] logInfo - Log information structure reference
 545 // @param[in] fmtStr - Formatted string
 546 // This function prints log into console or log file.
 547 ///////////////////////////////////////////////////////////////////////////////////////////////////
 548 void logLevSpl(SPL_ARGDATA* log, LOG_INFO & logInfo, const char* fmtStr, ...)
 549 {
 550    va_list argList;
 551   const char* file = logInfo.file.c_str();
 552
 553   printLogTime(log->logData.logTime);
 554    fprintf(g_fp, "[%s]%s:%d\n%s:%s:%d:", logInfo.modName.c_str(), file, logInfo.lineno, g_logStr[log->logData.logLevel], g_splStr[log->splEnum], log->splArg);
 555
 556    va_start(argList,fmtStr);
 557    vfprintf(g_fp, fmtStr, argList);
 558    va_end(argList);
 559 }
 560
 561 ///////////////////////////////////////////////////////////////////////////////////////////////////
 562 // @param[in] log - LOG Data
 563 // This function converts binary log with special arguments into text format.
 564 ///////////////////////////////////////////////////////////////////////////////////////////////////
 565 void logArgSpl(SPL_ARGDATA* log)
 566 {
 567 #ifdef TEST_MODE
 568 //  printf("LOG ARG SPL, LEVEL: %s\n", g_logStr[log->logData.logLevel]);
 569 #endif
 570   LOG_INFO & logInfo = g_mLogInfo[log->logData.logId];
 571   const char* file = logInfo.file.c_str();
 572
 573   logLevSpl(log, logInfo, logInfo.logStr.c_str(),log->arg1, log->arg2, log->arg3, log->arg4);
 574 }
 575
 576 ///////////////////////////////////////////////////////////////////////////////////////////////////
 577 // @param[in] ltime - Log time
 578 // This function prints log time using standard c formating function fprintf
 579 ///////////////////////////////////////////////////////////////////////////////////////////////////
 580 void printLogTime(LOGTIME & ltime)
 581 {
 582   struct tm* tm;
 583   time_t curTimeSec;
 584   U32 secElapsedFromBeg;
 585   U32 ttiNum;
 586   U32 miliseconds;
 587
 588   ttiNum = ltime.ms_tti;
 589   secElapsedFromBeg = ttiNum/1000;
 590   miliseconds = ttiNum%1000;
 591   curTimeSec   = g_basetimeSec + secElapsedFromBeg;
 592
 593   /* Obtain the time of day, and convert it to a tm struct. --*/
 594   tm = localtime (&curTimeSec);
 595
 596   if(NULL != tm)
 597    {
 598       fprintf(g_fp,"[%d-%d-%d %d:%d:%d.%03d]", tm->tm_mday, tm->tm_mon+1, tm->tm_year+1900,
 599             tm->tm_hour, tm->tm_min,tm->tm_sec,miliseconds);
 600    }
 601 }
 602
 603 ///////////////////////////////////////////////////////////////////////////////////////////////////
 604 // @param[in] logId - Log id which is unique to each log
 605 // This function checks if the given log id is valid based on the logdb information loaded into
 606 // memory.
 607 ///////////////////////////////////////////////////////////////////////////////////////////////////
 608 bool invalidLogId(LOGID logId)
 609 {
 610    /* if this is a time reference this is valid log */
 611    if( g_mLogInfo.find(logId) == g_mLogInfo.end() )
 612    {
 613       if(logId != L_TIME_REFERENCE)
 614       {
 615          fprintf(stderr, "Invalid log id %d\n",logId);
 616       }
 617       return true;
 618    }
 619    return false;
 620 }
 621
 622 ///////////////////////////////////////////////////////////////////////////////////////////////////
 623 // This function parse and reads the logdb file. Extracts the information and stores into map data
 624 // structure.
 625 ///////////////////////////////////////////////////////////////////////////////////////////////////
 626 void loadLogDb()
 627 {
 628   std::ifstream logdb(cmdlinearg::g_sLogDb.c_str());
 629
 630   if(logdb.is_open() == false) {
 631     fprintf(stderr, "Failed to open file %s\n", cmdlinearg::g_sLogDb.c_str());
 632     _exit(0);
 633   }
 634
 635   LOGID logId; LOG_INFO logInfo;
 636   std::string line;
 637    std::string & lstr = logInfo.logStr;
 638
 639   while( getline(logdb, line) )
 640   {
 641     std::istringstream iss(line);
 642     int pos = 0, newpos=0;
 643
 644     logId = atol( line.substr(pos, newpos=line.find(';', pos)).c_str() );
 645
 646     pos = newpos+1;
 647     logInfo.lineno = atol( line.substr(pos, (newpos=line.find(';', pos)) - pos).c_str() );
 648
 649     pos = newpos+1;
 650     logInfo.modName = line.substr(pos, (newpos=line.find(';', pos)) - pos);
 651
 652     pos = newpos+3;
 653     logInfo.file = line.substr(pos, (newpos=line.find('\"', pos)) - pos);
 654
 655       pos=line.find('\"',newpos+1) + 1;
 656     logInfo.logStr = line.substr(pos, (newpos=line.find_last_of("\"", pos)) - pos);
 657       lstr.erase(std::remove(lstr.begin(),lstr.end(),'\"')++,lstr.end());
 658
 659
 660 #ifdef TEST_MODE_0
 661     std::cout << "LOG Id:" << logId << " FILE:" << logInfo.file << " lineno:" << logInfo.lineno;
 662     std::cout << " MOD Name: " << logInfo.modName << std::endl;
 663     std::cout << "LOG STR:[" << logInfo.logStr << "]" <<  std::endl;
 664 #endif
 665
 666     logInfo.logStr+= "\n\n";
 667
 668     g_mLogInfo[logId] = logInfo;
 669   }
 670
 671   logdb.close();
 672
 673   logInfo.file = "NULL";
 674   logInfo.lineno = 0;
 675   logInfo.modName = "RLOG";
 676   logInfo.logStr =  RLOG_SEGFAULT_STR;
 677   g_mLogInfo[L_SIGSEGV] = logInfo;
 678
 679 }
 680
 681 ///////////////////////////////////////////////////////////////////////////////////////////////////
 682 // @arg[in] argc  - Number of arguments
 683 // @arg[in] argv - Command line arguments
 684 // This function parses the command line input parameters.
 685 ///////////////////////////////////////////////////////////////////////////////////////////////////
 686 void readCmdLineArgs(int argc,char **argv)
 687 {
 688   using namespace cmdlinearg;
 689    /* getopt_long stores the option index here */
 690    int c, option_index = 0;
 691
 692    while(  (c = getopt_long(argc, argv, "p:f:l:o:b:i:", long_options,&option_index)) != -1 )
 693    {
 694       switch(c)
 695        {
 696            case 'p':
 697                 std::cout<<"option -p with value = " << optarg << std::endl;
 698                 cmdlinearg::g_port = atoi(optarg);
 699                 break;
 700            case 'f':
 701                 std::cout<<"option -f with value = "<< optarg << std::endl;
 702                 cmdlinearg::g_sFileDb = optarg;
 703                 break;
 704            case 'l':
 705                 std::cout<<"option -l with value = "<< optarg << std::endl;
 706                 cmdlinearg::g_sLogDb = optarg;
 707                 break;
 708            case 'o':
 709                 std::cout<<"option -o with value = " << optarg << std::endl;
 710                 cmdlinearg::g_sOutFile = optarg;
 711                 break;
 712            case 'b':
 713                 std::cout<<"option -b with value = " << optarg << std::endl;
 714                 cmdlinearg::g_sBinLogFile = optarg;
 715                 break;
 716            case 'i':
 717                 std::cout<<"option -i with value = " << optarg << std::endl;
 718                 cmdlinearg::g_ipAddr = optarg;
 719                 break;
 720         defult:
 721           std::cout << "Invalid arguments" << std::endl;
 722           exit(0);
 723     }
 724   }
 725
 726 //  if( g_port == 0 && g_sBinLogFile.empty() )
 727 //    printUsage();
 728
 729 }
 730
 731 ///////////////////////////////////////////////////////////////////////////////////////////////////
 732 // This functin prints the binary log application usage.
 733 ///////////////////////////////////////////////////////////////////////////////////////////////////
 734 void printUsage()
 735 {
 736   printf("Usage: postproc [-f <filedb> ] [-l <logdb>] [-b <binlog> | -p <port> ] [-o <outfile>] \n");
 737   printf("\t[--filedb | -p <input file db > ]\n");
 738   printf("\t[--logdb  | -l <input log db > ]\n");
 739   printf("\t[--binlog | -b <input binary log file> ]\n");
 740   printf("\t[--ofile  | -o <output text log file> ]\n");
 741   printf("\t[--port   | -p <port number> ]\n");
 742   _exit(0);
 743 }
 744
 745 /**********************************************************************
 746          End of file
 747 **********************************************************************/