开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
cdrserver.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：70k
源码类别：

MySQL数据库

开发平台：

Visual C++

cdrserver.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* **************************************************************** */
  18. /*                                                                  */
  19. /*  S E R V . T C P                                                 */
  20. /*  * This is an example program that demonstrates the use of       */
  21. /*    stream sockets as an IPC mechanism. This contains the server, */
  22. /*    and is intended to operate in conjunction with the client     */
  23. /*    program found in client.tcp. Together, these two programs     */
  24. /*    demonstrate many of the features of sockets, as well as good  */
  25. /*    conventions for using these features.                         */
  26. /*  * This program provides a service called "example". In order for*/
  27. /*    it to function, an entry for it needs to exist in the         */
  28. /*    ./etc/services file. The port address for this service can be */
  29. /*    any port number that is likely to be unused, such as 22375,   */
  30. /*    for example. The host on which the client will be running     */
  31. /*    must also have the same entry (same port number) in its       */
  32. /*    ./etc/services file.                                          */
  33. /* **************************************************************** */
  35. #include <ndb_global.h>
  37. /******** NDB INCLUDE ******/
  38. #include <NdbApi.hpp>
  39. /***************************/
  40. /*#include <sys/shm.h>*/
  41. #include <pthread.h>
  42. #include <sys/sem.h>
  43. #include <sys/shm.h>
  44. #include <netinet/in.h>
  45. #include <signal.h>
  46. #include <netdb.h>
  47. #include <time.h>
  48. #include <synch.h>
  49. #include <sched.h>
  51. extern "C" {
  52. #include "utv.h"
  53. #include "vcdrfunc.h"
  54. #include "bcd.h"
  55. }
  57. #ifndef TESTLEV
  58. #define TESTLEV
  59. #endif
  60. //#define DEBUG
  61. //#define MYDEBUG
  62. //#define SETDBG
  64. //#define ops_before_exe 64
  65. #define MAXOPSEXEC 1024
  67. /* Used in nanosleep */
  68. /**** NDB ********/
  69. static  int bTestPassed;
  70. void create_table(Ndb* pMyNdb);
  71. void error_handler(const char* errorText);
  72. /*****************/
  73. static struct timespec tmspec1;
  74. static int server(long int);
  76. /* Function for initiating the cdr-area and make it clean for ongoing calls */
  78. static int s;                          /* connected socket descriptor */
  79. static int ls;                         /* listen socket descriptor */
  81. static struct hostent *hp;             /* pointer to host info for remote host */
  82. static struct servent *sp;             /* pointer to service information */
  84. struct linger linger;           /* allow a lingering, graceful close; */
  85.                                 /* used when setting SO_LINGER */
  87. static struct sockaddr_in myaddr_in;   /* for local socket address */
  88. static struct sockaddr_in peeraddr_in; /* for peer socket address */
  90. static FILE *fi;                       /* Log output */
  91. static char temp[600]="";
  93. static int ops_before_exe = 1;  /* Number of operations per execute, default is 1,
  94.    but it can be changed with the -o parameter. */
  96. /*----------------------------------------------------------------------
  98.      M A I N
  99.      * This routine starts the server. It forks, leaving the child
  100.      to do all the work, so it does not have to be run in the
  101.      background. It sets up the listen socket, and for each incoming
  102.      connection, it forks a child process to process the data. It
  103.      will loop forever, until killed by a signal.
  105.   ----------------------------------------------------------------------*/
  107. /****** NDB *******/
  108. static char *tableName = "VWTABLE";
  109. /******************/
  111. #include <iostream>
  112. using namespace std;
  114. int main(int argc, const char** argv)
  115. {
  116.   ndb_init();
  117.         /******** NDB ***********/
  118. /*
  119.         Ndb                   MyNdb( "TEST_DB" );
  120.         int                   tTableId;
  121. */
  122.         /************************/
  123. char  tmpbuf[400];
  124. /* Loop and status variables */
  125. int  i,j,found;
  127. /* Used by the server */
  128.         int  addrlen;
  130. /* return code used with functions */
  131. int  rc;
  133.   i = 1;
  134.   while (argc > 1)
  135.   {
  136.     if (strcmp(argv[i], "-o") == 0)
  137.     {
  138.       ops_before_exe = atoi(argv[i+1]);
  139.       if ((ops_before_exe < 1) || (ops_before_exe > MAXOPSEXEC))
  140.       {
  141. cout << "Number of operations per execute must be at least 1, and at most " << MAXOPSEXEC << endl;
  142. exit(1);
  143.       }
  145.     }
  146.     else
  147.     {
  148.       cout << "Invalid parameter!" << endl << "Look in cdrserver.C for more info." << endl;
  149.       exit(1);
  150.     }
  152.     argc -= 2;
  153.     i = i + 2;
  154.   }
  157.         /* Setup log handling */
  158.         logname(temp,"Cdrserver","Mother","");
  159. puts(temp);
  160.         fi=fopen(temp,"w");
  161. if (fi == NULL)
  162. {
  163. perror(argv[0]);
  164. exit(EXIT_FAILURE);
  165. }
  166.         m2log(fi,"Initiation of program");
  168.         /***** NDB ******/
  169. /*
  170.         MyNdb.init();
  171.         if (MyNdb.waitUntilReady(30) != 0)
  172.         {
  173.                 puts("Not ready");
  174.                 exit(-1);
  175.         }
  176.         tTableId = MyNdb.getTable()->openTable(tableName);
  177.         if (tTableId == -1)
  178.         {
  179.                 printf("%d: Creating table",getpid());
  180.                 create_table(&MyNdb);
  181.         }
  182. else printf("%d: Table already create",getpid());
  183. */
  185.         /****************/
  187.         /* clear out address structures */
  188.         memset ((char *)&myaddr_in, 0, sizeof(struct sockaddr_in));
  189.         memset ((char *)&peeraddr_in, 0, sizeof(struct sockaddr_in));
  191.         m2log(fi,"Socket setup starting");
  193.         /* Set up address structure for the listen socket. */
  194.         myaddr_in.sin_family = AF_INET;
  196.         /* The server should listen on the wildcard address,            */
  197.         /*   rather than its own internet address. This is              */
  198.         /*   generally good practice for servers, because on            */
  199.         /*   systems which are connected to more than one               */
  200.         /*   network at once will be able to have one server            */
  201.         /*   listening on all networks at once. Even when the           */
  202.         /*   host is connected to only one network, this is good        */
  203.         /*   practice, because it makes the server program more         */
  204.         /*   portable.                                                  */
  206.         myaddr_in.sin_addr.s_addr = INADDR_ANY;
  207.         /* Find the information for the "cdrserver" server              */
  208.         /*   in order to get the needed port number.                    */
  210.         sp = getservbyname ("cdrserver", "tcp");
  211.         if (sp == NULL) {
  212.                 m2log(fi,"Service cdrserver not found in /etc/services");
  213.                 m2log(fi,"Terminating.");
  214.                 exit(EXIT_FAILURE);
  215.         }
  217.         myaddr_in.sin_port = sp->s_port;
  219.         /* Create the listen socket.i                                   */
  221.         ls = socket (AF_INET, SOCK_STREAM, 0);
  222.         if (ls == -1) {
  223.                 m2log(fi,"Unable to create socket");
  224.                 m2log(fi,"Terminating.");
  225.                 exit(EXIT_FAILURE);
  226.         }
  227.         printf("Socket createdn");
  228.         printf("Wait..........n");
  229.         /* Bind the listen address to the socket.                       */
  230.         if (bind(ls,(struct sockaddr*)&myaddr_in, sizeof(struct sockaddr_in)) == -1) {
  231.                 m2log(fi,"Unable to bind address");
  232.                 m2log(fi,"Terminating.");
  233.                 exit(EXIT_FAILURE);
  234.         }
  236.         /* Initiate the listen on the socket so remote users            */
  237.         /*   can connect. The listen backlog is set to 5, which         */
  238.         /*   is the largest currently supported.                        */
  240.         if (listen(ls, 5) == -1) {
  241.                 m2log(fi,"Unable to listen on socket");
  242.                 m2log(fi,"Terminating.");
  243.                 exit(EXIT_FAILURE);
  244.         }
  246.         /* Now, all the initialization of the server is                 */
  247.         /*   complete, and any user errors will have already            */
  248.         /*   been detected. Now we can fork the daemon and              */
  249.         /*   return to the user. We need to do a setpgrp                */
  250.         /*   so that the daemon will no longer be associated            */
  251.         /*   with the user's control terminal. This is done             */
  252.         /*   before the fork, so that the child will not be             */
  253.         /*   a process group leader. Otherwise, if the child            */
  254.         /*   were to open a terminal, it would become associated        */
  255.         /*   with that terminal as its control terminal. It is          */
  256.         /*   always best for the parent to do the setpgrp.              */
  258.         m2log(fi,"Socket setup completed");
  259.         m2log(fi,"Start server");
  261.         setpgrp();
  263. /* Initiate the tmspec struct for use with nanosleep() */
  264.         tmspec1.tv_sec = 0;
  265.         tmspec1.tv_nsec = 1;
  267. printf("Waiting for client to connect.........n");
  268. printf("Donen");
  269.         switch (fork()) {
  270.            case -1: /* Unable to fork, for some reason. */
  271.                 m2log(fi,"Failed to start server");
  272.                 m2log(fi,"Terminating.");
  273.                 fclose(fi);
  274.                 perror(argv[0]);
  275.                 fprintf(stderr, "%s: unable to fork daemonn", argv[0]);
  276.                 exit(EXIT_FAILURE);
  278.    break;
  279.            case 0: /* The child process (daemon) comes here.            */
  280.                 m2log(fi,"Server started");
  282.                /* Close stdin and stderr so that they will not          */
  283.                /*   be kept open. Stdout is assumed to have been        */
  284.                /*   redirected to some logging file, or /dev/null.      */
  285.                /*   From now on, the daemon will not report any         */
  286.                /*   error messages. This daemon will loop forever,      */
  287.                /*   waiting for connections and forking a child         */
  288.                /*   server to handle each one.                          */
  290.                close((int)stdin);
  291.                close((int)stderr);
  292.                /* Set SIGCLD to SIG_IGN, in order to prevent            */
  293.                /*   the accumulation of zombies as each child           */
  294.                /*   terminates. This means the daemon does not          */
  295.                /*   have to make wait calls to clean them up.           */
  297.                signal(SIGCLD, SIG_IGN);
  298.                for(EVER) {
  299. if ((checkchangelog(fi,temp))==0)
  300.                           m2log(fi,"Waiting for connection");
  301.                        /* Note that addrlen is passed as a pointer      */
  302.                        /*  so that the accept call can return the       */
  303.                        /*  size of the returned address.                */
  305.                        addrlen = sizeof(struct sockaddr_in);
  307.                        /* This call will block until a new              */
  308.                        /*   connection arrives. Then, it will           */
  309.                        /*   return the address of the connecting        */
  310.                        /*   peer, and a new socket descriptor, s,       */
  311.                        /*   for that connection.                        */
  313.                         s = accept(ls,(struct sockaddr*) &peeraddr_in, &addrlen);
  314.        #ifdef MYDEBUG
  315.    puts("accepted");
  316.        #endif
  317. if ((checkchangelog(fi,temp))==0)
  318.                           m2log(fi,"Connection attempt from a client");
  319. if ((checkchangelog(fi,temp))==0)
  320.                           m2log(fi,"Start communication server");
  322.                         if ( s == -1) exit(EXIT_FAILURE);
  323.                         switch (fork()) {
  324.                            case -1: /* Can't fork, just exit. */
  325. if ((checkchangelog(fi,temp))==0)
  326.                                   m2log(fi,"Start communication server failed.");
  327.                                 exit(EXIT_FAILURE);
  328.    break;
  329.                            case 0: /* Child process comes here. */
  331. /* Get clients adress and save it in the info area */
  332. /* Keep track of how many times the client connects to the server */
  333. printf("Connect attempt from client %un",peeraddr_in.sin_addr.s_addr);
  334.                                 server(peeraddr_in.sin_addr.s_addr);
  335.                                 exit(EXIT_FAILURE);
  336.    break;
  337.                            default: /* Daemon process comes here. */
  338.                                 /* The daemon needs to remember         */
  339.                                 /*     to close the new accept socket   */
  340.                                 /*     after forking the child. This    */
  341.                                 /*     prevents the daemon from running */
  342.                                 /*     out of file descriptor space. It */
  343.                                 /*     also means that when the server  */
  344.                                 /*     closes the socket, that it will  */
  345.                                 /*     allow the socket to be destroyed */
  346.                                 /*     since it will be the last close. */
  347.                                 close(s);
  348.    break;
  349.                         }
  350.                }
  351.            default: /* Parent process comes here. */
  352.                exit(EXIT_FAILURE);
  353.        }
  354.   return EXIT_SUCCESS;
  355. }
  357. /*----------------------------------------------------------------------
  359.     S E R V E R
  360.     * This is the actual server routine that the daemon forks to
  361.       handle each individual connection. Its purpose is to receive
  362.       the request packets from the remote client, process them,
  363.       and return the results to the client. It will also write some
  364.       logging information to stdout.
  366.   ----------------------------------------------------------------------*/
  368. server(long int servernum)
  369. {
  370. /******** NDB ***********/
  371.    Ndb                   MyNdb( "TEST_DB" );
  372.    int                   tTableId;
  373. NdbConnection *MyTransaction;
  374. NdbOperation *MyOperation;
  375. int check;
  376. int c1 = 0;
  377. int c2 = 0;
  378. int c3 = 0;
  379. int c4 = 0;
  380. int act_index = 0;
  381. /************************/
  382.         register unsigned int   reqcnt;         /* keeps count of number of requests */
  383.         register unsigned int   i;           /* Loop counters */
  384. register int x;
  385.         register short          done;           /* Loop variable */
  386. short int found;
  388. /* The server index number */
  389. int  thisServer;
  391. /* Variables used to keep track of some statistics */
  392. time_t ourtime;
  393. time_t tmptime;
  394. int  tmpvalue;
  395. long int tmptransfer;
  396. long int transfer;
  397. int ops = 0;
  399. /* Variables used by the server */
  400.         char     buf[400];       /* This example uses 10 byte messages. */
  401.         char     *inet_ntoa();
  402.         char     *hostname;      /* points to the remote host's name string */
  403.         int      len;
  404.         int      rcvbuf_size;
  406. long ctid;
  408.         unsigned char  uc;
  410. /* Variables used by the logging facilitiy */
  411.         char     msg[600];
  412.         char     crap[600];
  413.         char     lognamn[600];
  415.         FILE     *log;
  417. /* scheduling parameter for pthread */
  418. struct sched_param  param1,param2,param3;
  420.         /* Header information */
  421. /* cdrtype not used */
  422.         /*short            cdrtype;   */   /* 1 CDR Typ                                            */
  423.         short            cdrlen;         /* 2 CDR recored length in bytes excluding CDR type     */
  424.         short            cdrsubtype;     /* 1 CDR subtype                                        */
  425.         unsigned int     cdrid;          /* 8 CDR unique number of each call                     */
  426.         unsigned int     cdrtime;        /* 4 CDR Time in seconds                                */
  427.         short            cdrmillisec;    /* 2 CDR Milliseconds                                   */
  428.         short            cdrstatus;      /* 1 CDR For future use                                 */
  429.         short            cdrequipeid;    /* 1 CDR Equipment id                                   */
  430.         int              cdrreserved1;   /* 4 CDR For future use                                 */
  432.         /* Defined or calculated for each record */
  433.         int              cdrrestlen;     /*   Unprocessed data left in record in bytes   */
  435.         /* Gemensamma datatyper */
  436.         unsigned short   parmtype_prev;  /* 1 Parameter type                                     */
  437.         unsigned short   parmtype;       /* 1 Parameter type                                     */
  438.         unsigned short   parmlen;        /* 1 Parameter type                                     */
  440. int rc; /* return code for functions */
  442. /* Attribute object used with threads */
  443. pthread_attr_t  attr1;
  444. pthread_attr_t  attr2;
  445. pthread_attr_t  attr3;
  446. struct cdr_record *tmpcdrptr,*ftest;
  447. void *dat;
  449. int error_from_client = 0;
  451.         /* Konstanter           */
  452.         const int        headerlen = 24;         /*   Length of header record                    */
  454.         parmtype_prev = 99;
  455. reqcnt = 0;
  457.         /* Close the listen socket inherited from the daemon. */
  458.         close(ls);
  460. printf("Use the readinfo program to get information about server statusnn");
  462. if((checkchangelog(fi,temp))==0)
  463.           c2log(fi,"Communication server started");
  465.         /* Look up the host information for the remote host     */
  466.         /* that we have connected with. Its internet address    */
  467.         /* was returned by the accept call, in the main         */
  468.         /* daemon loop above.                                   */
  470.         hp=gethostbyaddr((char *) &peeraddr_in.sin_addr,sizeof(struct in_addr),peeraddr_in.sin_family);
  472.         if (hp == NULL) {
  473.                 /* The information is unavailable for the remote        */
  474.                 /* host. Just format its internet address to be         */
  475.                 /* printed out in the logging information. The          */
  476.                 /* address will be shown in "internet dot format".      */
  478. /*
  479.                 hostname = inet_ntoa(peeraddr_in.sin_addr);
  480. */
  481. sprintf(hostname,"Test");
  482.                 logname(lognamn,"Cdrserver","Child",hostname);
  483.         }
  484.         else {
  485.                 hostname = hp->h_name; /* point to host's name */
  486.                 logname(lognamn,"Cdrserver","Child",hostname);
  487.         }
  489.         log=fopen(lognamn,"w");
  490. if (log == NULL)
  491. {
  492. perror(hostname);
  493. exit(EXIT_FAILURE);
  494. }
  495.         n2log(log,"Setup in progress");
  496.         /* Log a startup message. */
  498.         /* The port number must be converted first to host byte */
  499.         /* order before printing. On most hosts, this is not    */
  500.         /* necessary, but the ntohs() call is included here so  */
  501.         /* that this program could easily be ported to a host   */
  502.         /* that does require it.                                */
  504.         BaseString::snprintf(msg,sizeof(msg),"Startup from %s port %u",hostname,ntohs(peeraddr_in.sin_port));
  505. if ((checkchangelog(fi,temp))==0)
  506.           c2log(fi,msg);
  507.         n2log(log,msg);
  508.         BaseString::snprintf(msg,sizeof(msg),"For further information, see log(%s)",lognamn);
  509. if ((checkchangelog(fi,temp))==0)
  510.           c2log(fi,msg);
  512.         /* Set the socket for a lingering, graceful close.              */
  513.         /* This will cause a final close of this socket to wait until   */
  514.         /* all * data sent on it has been received by the remote host.  */
  516.         linger.l_onoff  =1;
  517.         linger.l_linger =0;
  518.         if (setsockopt(s, SOL_SOCKET, SO_LINGER,(const char*)&linger,sizeof(linger)) == -1) {
  519.                 BaseString::snprintf(msg,sizeof(msg),"Setting SO_LINGER, l_onoff=%d, l_linger=%d",linger.l_onoff,linger.l_linger);
  520. if ((checkchangelog(log,lognamn))==0)
  521.            n2log(log,msg);
  522.                 goto errout;
  523.         }
  525.         /* Set the socket for a lingering, graceful close.                              */
  526.         /* This will cause a final close of this socket to wait until all * data sent   */
  527.         /* on it has been received by the remote host.                                  */
  529.         rcvbuf_size=64*1024;
  531.         if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,(const char*) &rcvbuf_size,sizeof(rcvbuf_size)) == -1) {
  532.                 BaseString::snprintf(msg,sizeof(msg),"Setting SO_RCVBUF = %d",rcvbuf_size);
  533. if ((checkchangelog(log,lognamn))==0)
  534.            n2log(log,msg);
  535.                 goto errout;
  536.         }
  538.         /* Set nodelay on socket */
  539.         n2log(log,"Port setup complete");
  541.         /* Go into a loop, receiving requests from the remote           */
  542.         /* client. After the client has sent the last request,          */
  543.         /* it will do a shutdown for sending, which will cause          */
  544.         /* an end-of-file condition to appear on this end of the        */
  545.         /* connection. After all of the client's requests have          */
  546.         /* been received, the next recv call will return zero           */
  547.         /* bytes, signalling an end-of-file condition. This is          */
  548.         /* how the server will know that no more requests will          */
  549.         /* follow, and the loop will be exited.                         */
  551.         n2log(log,"Setup completed");
  553. /* Fetch the process id for the server */
  555. /* Inititate the variables used for counting transfer rates and rec/sec */
  556. tmpvalue    = 0;
  557. tmptime     = 0;
  558. tmptransfer = 0;
  559. transfer = 0;
  561. printf("Client %s connectednStarting to process the datann",hostname);
  563. tmpcdrptr = (struct cdr_record*)malloc(sizeof(struct cdr_record));
  565. /***** NDB ******/
  566. MyNdb.init();
  567. if (MyNdb.waitUntilReady(30) != 0)
  568. {
  569. puts("Not ready");
  570. exit(-1);
  571. }
  572. tTableId = MyNdb.getTable()->openTable(tableName);
  573.        if (tTableId == -1) 
  574. {
  575. printf("%d: Creating table",getpid());
  576.          create_table(&MyNdb);
  577. }
  578. else printf("%d: Table already created",getpid());
  579.       
  580. /****************/
  582.         while (len = recv(s,buf,headerlen,MSG_WAITALL)) {
  583.                 if (len == -1) {
  584.          snprintf(msg,sizeof(msg),"Error from recv");
  585. if ((checkchangelog(log,lognamn))==0)
  586.            n2log(log,msg);
  587.                         goto errout; /* error from recv */
  588.                 }
  590.                 /* The reason this while loop exists is that there              */
  591.                 /* is a remote possibility of the above recv returning          */
  592.                 /* less than 10 bytes. This is because a recv returns           */
  593.                 /* as soon as there is some data, and will not wait for         */
  594.                 /* all of the requested data to arrive. Since 10 bytes          */
  595.                 /* is relatively small compared to the allowed TCP              */
  596.                 /* packet sizes, a partial receive is unlikely. If              */
  597.                 /* this example had used 2048 bytes requests instead,           */
  598.                 /* a partial receive would be far more likely.                  */
  599.                 /* This loop will keep receiving until all 10 bytes             */
  600.                 /* have been received, thus guaranteeing that the               */
  601.                 /* next recv at the top of the loop will start at               */
  602.                 /* the begining of the next request.                            */
  604.                 for (;len < headerlen;) {
  605.                         x = recv(s,buf,(headerlen-len),0);
  606.                         if (x == -1) {
  607.          snprintf(msg,sizeof(msg),"Error from recv");
  608. if ((checkchangelog(log,lognamn))==0)
  609.            n2log(log,msg);
  610.                                 goto errout; /* error from recv */
  611.                         }
  612.                         len=len+x;
  613.                 }
  615.                 if (ops == 0) {
  616.                MyTransaction = MyNdb.startTransaction();
  617.            if (MyTransaction == NULL)
  618.          error_handler(MyNdb.getNdbErrorString());
  619.                 }//if
  621.        MyOperation = MyTransaction->getNdbOperation(tableName);
  622.        if (MyOperation == NULL)
  623.          error_handler(MyTransaction->getNdbErrorString());
  624.                 /*------------------------------------------------------*/
  625.                 /* Parse header of CDR records                          */
  626.                 /*------------------------------------------------------*/
  628.                 /*------------------------------------------------------*/
  629.                 /* 1. Type of cdr                                       */
  630.                 /*------------------------------------------------------*/
  631. /* Not used for the moment
  632.                 cdrtype=(char)buf[0];
  633. */
  634.                 /*------------------------------------------------------*/
  635.                 /* 2. Total length of CDR                               */
  636.                 /*------------------------------------------------------*/
  637.                 swab(buf+1,buf+1,2);
  638.                 memcpy(&cdrlen,buf+1,2);
  639.                 /*------------------------------------------------------*/
  640.                 /* 3. Partial type of CDR                               */
  641.                 /*------------------------------------------------------*/
  642.                 cdrsubtype=(char)buf[3];
  643. switch (cdrsubtype)
  644. {
  645. case 0:
  646. c1++;
  647. tmpcdrptr->CallAttemptState = 1;
  648. check = MyOperation->insertTuple();
  649. break;
  650. case 1:
  651. c2++;
  652. tmpcdrptr->CallAttemptState = 2;
  653. check = MyOperation->updateTuple();
  654. break;
  655. case 2:
  656. c3++;
  657. tmpcdrptr->CallAttemptState = 3;
  658. check = MyOperation->deleteTuple();
  659. break;
  660. case 3:
  661. c4++;
  662. tmpcdrptr->CallAttemptState = 4;
  663. check = MyOperation->deleteTuple();
  664. break;
  665. if (check == -1)
  666. error_handler(MyTransaction->getNdbErrorString());
  667. }
  668.                 /*cdrsubtype=(cdrsubtype << 24) >> 24;*/
  669.                 /*------------------------------------------------------*/
  670.                 /* 4. ID number                                         */
  671.                 /*------------------------------------------------------*/
  672.                 /*swab(buf+4,buf+4,4);*/ /* ABCD -> BADC */
  673. /*
  674.                 swab(buf+4,buf+4,4);
  675.                 swab(buf+5,buf+5,2);
  676.                 swab(buf+6,buf+6,2);
  677.                 swab(buf+4,buf+4,2);
  678.                 swab(buf+5,buf+5,2);
  679. */
  680.                 memcpy(&cdrid,buf+4,4);
  681. tmpcdrptr->CallIdentificationNumber = cdrid;
  682. #ifdef SETDBG
  683. puts("CIN");
  684. #endif
  685. check = MyOperation->equal("CIN",(char*)&cdrid);
  686. if (check == -1)
  687. error_handler(MyTransaction->getNdbErrorString());
  688. #ifdef SETDBG
  689. puts("CAS");
  690. #endif
  692. if (cdrsubtype < 2)
  693. {
  694. check = MyOperation->setValue("CAS",(char*)&cdrsubtype);
  695. if (check == -1)
  696. error_handler(MyTransaction->getNdbErrorString());
  697. }
  698.                 /*------------------------------------------------------*/
  699.                 /* 5. Time stamp                                        */
  700.                 /*------------------------------------------------------*/
  701.                 swab(buf+12,buf+12,4);
  702.                 swab(buf+13,buf+13,2);
  703.                 swab(buf+14,buf+14,2);
  704.                 swab(buf+12,buf+12,2);
  705.                 swab(buf+13,buf+13,2);
  706.                 memcpy(&cdrtime,buf+12,4);
  707. switch (cdrsubtype)
  708. {
  709. case 0:
  710. #ifdef SETDBG
  711. puts("START_TIME");
  712. #endif
  713. check = MyOperation->setValue("START_TIME",(char*)&cdrtime);
  714. break;
  715. case 1:
  716. #ifdef SETDBG
  717. puts("Start1");
  718. #endif
  719. check = MyOperation->setValue("StartOfCharge",(char*)&cdrtime);
  720. break;
  721. case 2:
  722. #ifdef SETDBG
  723. puts("Start2");
  724. #endif
  725. /*
  726. check = MyOperation->setValue("StopOfCharge",(char*)&cdrtime);
  727. */
  728. check = 0;
  729. break;
  730. if (check == -1)
  731. error_handler(MyTransaction->getNdbErrorString());
  732. }
  733.                 /*------------------------------------------------------*/
  734.                 /* 6. Milliseconds                                      */
  735.                 /*------------------------------------------------------*/
  736. /* Not used by application
  737.                 swab(buf+16,buf+16,2);
  738.                 memcpy(&cdrmillisec,buf+16,2);
  739. */
  740.                 /*------------------------------------------------------*/
  741.                 /* 7. CDR status reserverd for future use               */
  742.                 /*------------------------------------------------------*/
  743. /* Not used by application
  744.                 memcpy(&cdrstatus,buf+18,1);
  745. */
  746.                 /*------------------------------------------------------*/
  747.                 /* 8. CDR equipe id, number of sending equipement       */
  748.                 /*------------------------------------------------------*/
  749. /* Not used by application
  750.                 memcpy(&cdrequipeid,buf+19,1);
  751. */
  752.                 /*cdrequipeid=(cdrequipeid << 24) >> 24;*/
  753.                 /*------------------------------------------------------*/
  754.                 /* 9. CDR reserverd for furter use                      */
  755.                 /*------------------------------------------------------*/
  756. /* Not used by applikation
  757.                 swab(buf+20,buf+20,4);
  758.                 swab(buf+21,buf+21,2);
  759.                 swab(buf+22,buf+22,2);
  760.                 swab(buf+20,buf+20,2);
  761.                 swab(buf+21,buf+21,2);
  762.                 memcpy(&cdrreserved1,buf+20,4);
  763. */
  764.                 /*------------------------------------------------------*/
  765.                 /* calculate length of datapart in record               */
  766.                 /* Formula recordlength-headerlen-1                     */
  767.                 /*------------------------------------------------------*/
  768.                 cdrrestlen=cdrlen-(headerlen-1);
  769.                 /*------------------------------------------------------*/
  770.                 /* Finished with header                                 */
  771.                 /*------------------------------------------------------*/
  772.                 /* Read remaining cdr data into buffer for furter       */
  773.                 /* handling.                                            */
  774.                 /*------------------------------------------------------*/
  775.                 len = recv(s,buf,cdrrestlen,MSG_WAITALL);
  776.                 if (len == -1) {
  777.          snprintf(msg,sizeof(msg),"Error from recv");
  778. if ((checkchangelog(log,lognamn))==0)
  779.            n2log(log,msg);
  780.                         goto errout; /* error from recv */
  781.                 }
  782.                 for (;len<cdrrestlen;) {
  783.                         x = recv(s,buf,len-cdrrestlen,0);
  784.                         if (x == -1) {
  785.          snprintf(msg,sizeof(msg),"Error from recv");
  786. if ((checkchangelog(log,lognamn))==0)
  787.            n2log(log,msg);
  788.                                 goto errout; /* error from recv */
  789.                         }
  790.                         len=len+x;
  791.                 }
  792.                 done=FALSE;
  794. /* Count the transfer/sec */
  795. tmptransfer += cdrlen;
  796. if (cdrsubtype > 1) 
  797. {
  798. #ifdef SETDBG
  799. puts("Going to execute");
  800. #endif
  801.                                 ops++;
  802.                                 if (ops == ops_before_exe) {
  803.                                   ops = 0;
  804.                    check = MyTransaction->execute(Commit, CommitAsMuchAsPossible);
  805.                    if ((check == -1) && (MyTransaction->getNdbError() != 0))
  806.                          error_handler(MyTransaction->getNdbErrorString());
  807.                    MyNdb.closeTransaction(MyTransaction);
  808.   #ifdef SETDBG
  809. puts("Transaction closed");
  810.   #endif
  811.                                 }//if
  812. reqcnt++;
  813. continue;
  814. }
  815.                 for (x=0;x<=cdrrestlen && !done && cdrrestlen > 1;) {
  816.                         uc=buf[x];
  817.                         parmtype=uc;
  818.                         /*parmtype=(parmtype << 24) >> 24;*/ /* Modified in sun worked in hp */
  820.                         parmlen = buf[x+1];
  821.                         /*parmlen =(parmlen << 24) >> 24;*/
  822.                         x+=2;
  824.                         switch (parmtype) {
  825.                                 case 4:         /* Called party number */
  826.                                         bcd_decode2(parmlen,&buf[x],crap);
  827. tmpcdrptr->BSubscriberNumberLength = (char)parmlen;
  828.                                         strcpy(tmpcdrptr->BSubscriberNumber,crap);
  829. tmpcdrptr->BSubscriberNumber[parmlen] = '';
  830.                                         x=x+(parmlen/2);
  831.                                         if (parmlen % 2) x++;
  832.                                         tmpcdrptr->USED_FIELDS |=  B_BSubscriberNumber;
  833. #ifdef SETDBG
  834. puts("BNumber");
  835. #endif
  836. check = MyOperation->setValue("BNumber",(char*)&tmpcdrptr->BSubscriberNumber);
  837. if (check == -1)
  838. error_handler(MyTransaction->getNdbErrorString());
  839.                                 break;
  840.                                 case 9:         /* Calling Partys cataegory */
  841.                                         if (parmlen != 1) printf("ERROR: Calling partys category has wrong length %dn",parmlen);
  842.                                         else tmpcdrptr->ACategory=(char)buf[x];
  843.                                         x+=parmlen;
  844.                                         tmpcdrptr->USED_FIELDS |= B_ACategory;
  845. #ifdef SETDBG
  846. puts("ACategory");
  847. #endif
  848. check = MyOperation->setValue("ACategory",(char*)&tmpcdrptr->ACategory);
  849. if (check == -1)
  850. error_handler(MyTransaction->getNdbErrorString());
  851.                                 break;
  852.                                 case 10:        /* Calling Party Number */
  853.                                         bcd_decode2(parmlen,&buf[x],crap);
  854. tmpcdrptr->ASubscriberNumberLength = (char)parmlen;
  855.                                         strcpy(tmpcdrptr->ASubscriberNumber,crap);
  856. tmpcdrptr->ASubscriberNumber[parmlen] = '';
  857.                                         x=x+(parmlen/2);
  858.                                         if (parmlen % 2) x++;
  859.                                         tmpcdrptr->USED_FIELDS |= B_ASubscriberNumber;
  860. #ifdef SETDBG
  861. puts("ANumber");
  862. #endif
  863. check = MyOperation->setValue("ANumber",(char*)&tmpcdrptr->ASubscriberNumber);
  864. if (check == -1)
  865. error_handler(MyTransaction->getNdbErrorString());
  866.                                 break;
  867.                                 case 11:        /* Redirecting number */
  868.                                         bcd_decode2(parmlen,&buf[x],crap);
  869.                                         strcpy(tmpcdrptr->RedirectingNumber,crap);
  870.                                         x=x+(parmlen/2);
  871.                                         if (parmlen % 2) x++;
  872.                                         tmpcdrptr->USED_FIELDS |= B_RedirectingNumber;
  873. #ifdef SETDBG
  874. puts("RNumber");
  875. #endif
  876. check = MyOperation->setValue("RNumber",(char*)&tmpcdrptr->RedirectingNumber);
  877. if (check == -1)
  878. error_handler(MyTransaction->getNdbErrorString());
  879.                                 break;
  880.                                 case 17:        /* Called partys category */
  881.                                         if (parmlen != 1) printf("ERROR: Called partys category has wrong length %dn",parmlen);
  882.                                         else tmpcdrptr->EndOfSelectionInformation=(char)buf[x];
  883.                                         x+=parmlen;
  884.                                         tmpcdrptr->USED_FIELDS |= B_EndOfSelectionInformation;
  885. #ifdef SETDBG
  886. puts("EndOfSelInf");
  887. #endif
  888. check = MyOperation->setValue("EndOfSelInf",(char*)&tmpcdrptr->EndOfSelectionInformation);
  889. if (check == -1)
  890. error_handler(MyTransaction->getNdbErrorString());
  891.                                 break;
  892.                                 case 18:        /* Release reason */
  893.                                         if (parmlen != 1) printf("ERROR: Release reason has wrong length %dn",parmlen);
  894.                                         else tmpcdrptr->CauseCode=(char)buf[x];
  895.                                         x+=parmlen;
  896.                                         tmpcdrptr->USED_FIELDS |= B_CauseCode;
  897. #ifdef SETDBG
  898. puts("CauseCode");
  899. #endif
  900. check = MyOperation->setValue("CauseCode",(char*)&tmpcdrptr->CauseCode);
  901. if (check == -1)
  902. error_handler(MyTransaction->getNdbErrorString());
  903.                                 break;
  904.                                 case 19:        /* Redirection information */
  905.                                         switch (parmlen) {
  906.                                                 case 1:
  907.                                                         tmpcdrptr->ReroutingIndicator= (char)buf[x];
  908.                                                         tmpcdrptr->USED_FIELDS |= B_ReroutingIndicator;
  909.                                                 break;
  910.                                                 case 2:
  911.                                                         swab(buf+x,buf+x,2);
  912.                                                         tmpcdrptr->ReroutingIndicator= buf[x];
  913.                                                         tmpcdrptr->USED_FIELDS |= B_ReroutingIndicator;
  914.                                                 break;
  915.                                                 default :
  916.                                                         BaseString::snprintf(msg,sizeof(msg),"ERROR: Redirection information has wrong length %dn",parmlen);
  917.    if ((checkchangelog(log,lognamn))==0)
  918.                                                           n2log(log,msg);
  919.                                                 break;
  920. #ifdef SETDBG
  921. puts("RI");
  922. #endif
  923. check = MyOperation->setValue("RI",(char*)&tmpcdrptr->ReroutingIndicator);
  924. if (check == -1)
  925. error_handler(MyTransaction->getNdbErrorString());
  926.                                         }
  927.                                         x+=parmlen;
  928.                                 break;
  929.                                 case 32:        /* User to user information */
  930.                                         if (parmlen != 1) printf("ERROR: User to User information has wrong length %dn",parmlen);
  931.                                         else tmpcdrptr->UserToUserInformation=(char)buf[x];
  932.                                         x+=parmlen;
  933.                                         tmpcdrptr->USED_FIELDS |= B_UserToUserInformation;
  934. #ifdef SETDBG
  935. puts("UserToUserInf");
  936. #endif
  937. check = MyOperation->setValue("UserToUserInf",(char*)&tmpcdrptr->UserToUserInformation);
  938. if (check == -1)
  939. error_handler(MyTransaction->getNdbErrorString());
  940.                                 break;
  941.                                 case 40:        /* Original called number */
  942.                                         bcd_decode2(parmlen,&buf[x],crap);
  943.                                         strcpy(tmpcdrptr->OriginalCalledNumber,crap);
  944.                                         x=x+(parmlen/2);
  945.                                         if (parmlen % 2) x++;
  946.                                         tmpcdrptr->USED_FIELDS |= B_OriginalCalledNumber;
  947. #ifdef SETDBG
  948. puts("ONumber");
  949. #endif
  950. check = MyOperation->setValue("ONumber",(char*)&tmpcdrptr->OriginalCalledNumber);
  951. if (check == -1)
  952. error_handler(MyTransaction->getNdbErrorString());
  953.                                 break;
  954.                                 case 42:        /* User to user indicator */
  955.                                         if (parmlen != 1) printf("ERROR: User to User indicator has wrong length %dn",parmlen);
  956.                                         else tmpcdrptr->UserToUserIndicatior=(char)buf[x];
  957.                                         x+=parmlen;
  958.                                         tmpcdrptr->USED_FIELDS |= B_UserToUserIndicatior;
  959. #ifdef SETDBG
  960. puts("UserToUserInd");
  961. #endif
  962. check = MyOperation->setValue("UserToUserInd",(char*)&tmpcdrptr->UserToUserIndicatior);
  963. if (check == -1)
  964. error_handler(MyTransaction->getNdbErrorString());
  965.                                 break;
  966.                                 case 63:        /* Location number */
  967.                                         bcd_decode2(parmlen,&buf[x],crap);
  968.                                         strcpy(tmpcdrptr->LocationCode,crap);
  969.                                         x=x+(parmlen/2);
  970.                                         if (parmlen % 2) x++;
  971.                                         tmpcdrptr->USED_FIELDS |= B_LocationCode;
  972. #ifdef SETDBG
  973. puts("LocationCode");
  974. #endif
  975. check = MyOperation->setValue("LocationCode",(char*)&tmpcdrptr->LocationCode);
  976. if (check == -1)
  977. error_handler(MyTransaction->getNdbErrorString());
  978.                                 break;
  979.                                 case 240:       /* Calling Partys cataegory */
  980.                                         if (parmlen != 1) printf("ERROR: Calling partys category has wrong length %dn",parmlen);
  981.                                         else tmpcdrptr->NetworkIndicator=(char)buf[x];
  982.                                         x+=parmlen;
  983.                                         tmpcdrptr->USED_FIELDS |= B_NetworkIndicator;
  984. #ifdef SETDBG
  985. puts("NIndicator");
  986. #endif
  987. check = MyOperation->setValue("NIndicator",(char*)&tmpcdrptr->NetworkIndicator);
  988. if (check == -1)
  989. error_handler(MyTransaction->getNdbErrorString());
  990.                                 break;
  991.                                 case 241:       /* Calling Partys cataegory */
  992.                                         if (parmlen != 1) printf("ERROR: Calling partys category has wrong length %dn",parmlen);
  993.                                         else tmpcdrptr->TonASubscriberNumber=(char)buf[x];
  994.                                         x+=parmlen;
  995.                                         tmpcdrptr->USED_FIELDS |= B_TonASubscriberNumber;
  996. #ifdef SETDBG
  997. puts("TonANumber");
  998. #endif
  999. check = MyOperation->setValue("TonANumber",(char*)&tmpcdrptr->TonASubscriberNumber);
  1000. if (check == -1)
  1001. error_handler(MyTransaction->getNdbErrorString());
  1002.                                 break;
  1003.                                 case 242:       /* Calling Partys cataegory */
  1004.                                         if (parmlen != 1) printf("ERROR: Calling partys category has wrong length %dn",parmlen);
  1005.                                         else tmpcdrptr->TonBSubscriberNumber=(char)buf[x];
  1006.                                         x+=parmlen;
  1007.                                         tmpcdrptr->USED_FIELDS |= B_TonBSubscriberNumber;
  1008. #ifdef SETDBG
  1009. puts("TonBNumber");
  1010. #endif
  1011. check = MyOperation->setValue("TonBNumber",(char*)&tmpcdrptr->TonBSubscriberNumber);
  1012. if (check == -1)
  1013. error_handler(MyTransaction->getNdbErrorString());
  1014.                                 break;
  1015.                                 case 243:       /* Calling Partys cataegory */
  1016.                                         if (parmlen != 1) printf("ERROR: Calling partys category has wrong length %dn",parmlen);
  1017.                                         else tmpcdrptr->TonRedirectingNumber=(char)buf[x];
  1018.                                         x+=parmlen;
  1019.                                         tmpcdrptr->USED_FIELDS |= B_TonRedirectingNumber;
  1020. #ifdef SETDBG
  1021. puts("TonRNumber");
  1022. #endif
  1023. check = MyOperation->setValue("TonRNumber",(char*)&tmpcdrptr->TonRedirectingNumber);
  1024. if (check == -1)
  1025. error_handler(MyTransaction->getNdbErrorString());
  1026.                                 break;
  1027.                                 case 244:       /* Calling Partys cataegory */
  1028.                                         if (parmlen != 1) printf("ERROR: Calling partys category has wrong length %dn",parmlen);
  1029.                                         else tmpcdrptr->TonOriginalCalledNumber=(char)buf[x];
  1030.                                         x+=parmlen;
  1031.                                         tmpcdrptr->USED_FIELDS |= B_TonOriginalCalledNumber;
  1032. #ifdef SETDBG
  1033. puts("TonONumber");
  1034. #endif
  1035. check = MyOperation->setValue("TonONumber",(char*)&tmpcdrptr->TonOriginalCalledNumber);
  1036. if (check == -1)
  1037. error_handler(MyTransaction->getNdbErrorString());
  1038.                                 break;
  1039.                                 case 245:       /* Calling Partys cataegory */
  1040.                                         if (parmlen != 1) printf("ERROR: Calling partys category has wrong length %dn",parmlen);
  1041.                                         else tmpcdrptr->TonLocationCode=(char)buf[x];
  1042.                                         x+=parmlen;
  1043.                                         tmpcdrptr->USED_FIELDS |= B_TonLocationCode;
  1044. #ifdef SETDBG
  1045. puts("TonLocationCode");
  1046. #endif
  1047. check = MyOperation->setValue("TonLocationCode",(char*)&tmpcdrptr->TonLocationCode);
  1048. if (check == -1)
  1049. error_handler(MyTransaction->getNdbErrorString());
  1050.                                 break;
  1051.                                 case 252:       /* RINParameter Parameter */
  1052.                                         switch (parmlen) {
  1053.                                                 case 1:
  1054.                                                         tmpcdrptr->RINParameter=buf[x];
  1055.                                                         tmpcdrptr->USED_FIELDS |= B_RINParameter;
  1056.                                                 break;
  1057.                                                 case 2:
  1058.                                                         swab(buf+x,buf+x,2);
  1059.                                                         tmpcdrptr->RINParameter = buf[x] << 8;
  1060.                                                         tmpcdrptr->USED_FIELDS |= B_RINParameter;
  1061.                                                 break;
  1062.                                                 default :
  1063.                                                         BaseString::snprintf(msg,sizeof(msg),"ERROR: Rin parameter has wrong length %dn",parmlen);
  1064.    if ((checkchangelog(log,lognamn))==0)
  1065.                                                           n2log(log,msg);
  1066.                                                 break;
  1067.                                         }
  1068.                                         x+=parmlen;
  1069. #ifdef SETDBG
  1070. puts("RINParameter");
  1071. #endif
  1072. check = MyOperation->setValue("RINParameter",(char*)&tmpcdrptr->RINParameter);
  1073. if (check == -1)
  1074. error_handler(MyTransaction->getNdbErrorString());
  1075.                                 break;
  1076.                                 case 253:       /* OriginatingPointCode */
  1077.                                         switch (parmlen) {
  1078.                                                 case 2:
  1079.                                                         swab(buf+x,buf+x,2);
  1080.                                                         memcpy(&tmpcdrptr->OriginatingPointCode,(buf+x),2);
  1081.                                                         tmpcdrptr->USED_FIELDS |= B_OriginatingPointCode;
  1082.                                                 break;
  1083.                                                 case 3:
  1084.                                                         swab(buf+x,buf+x,2);
  1085.                                                         swab(buf+(x+1),buf+(x+1),2);
  1086.                                                         swab(buf+x,buf+x,2);
  1087.                                                         memcpy(&tmpcdrptr->OriginatingPointCode,(buf+x),3);
  1088.                                                         tmpcdrptr->USED_FIELDS |= B_OriginatingPointCode;
  1089.                                                 break;
  1090.                                                 default :
  1091.                                                         BaseString::snprintf(msg,sizeof(msg),"ERROR: OriginatingPointCode parameter has wrong length %dn",parmlen);
  1092.    if ((checkchangelog(log,lognamn))==0)
  1093.                                                           n2log(log,msg);
  1094.                                                 break;
  1095.                                         }
  1096.                                         x+=parmlen;
  1097. #ifdef SETDBG
  1098. puts("OPC");
  1099. #endif
  1100. check = MyOperation->setValue("OPC",(char*)&tmpcdrptr->OriginatingPointCode);
  1101. if (check == -1)
  1102. error_handler(MyTransaction->getNdbErrorString());
  1103.                                 break;
  1104.                                 case 254:       /* DestinationPointCode */
  1105.                                         switch (parmlen) {
  1106.                                                 case 2:
  1107.                                                         swab(buf+x,buf+x,2);
  1108.                                                         memcpy(&tmpcdrptr->DestinationPointCode,(buf+x),2);
  1109. /*
  1110.                                                         tmpcdrptr->DestinationPointCode = buf[x] << 8;
  1111. */
  1112.                                                         tmpcdrptr->USED_FIELDS |= B_DestinationPointCode;
  1113.                                                 break;
  1114.                                                 case 3:
  1115.                                                         swab(buf+x,buf+x,2);
  1116.                                                         swab(buf+(x+1),buf+(x+1),2);
  1117.                                                         swab(buf+x,buf+x,2);
  1118.                                                         memcpy(&tmpcdrptr->DestinationPointCode,(buf+x),3);
  1119.                                                         tmpcdrptr->USED_FIELDS |= B_DestinationPointCode;
  1120.                                                 break;
  1121.                                                 default :
  1122.                                                         BaseString::snprintf(msg,sizeof(msg),"ERROR: DestinationPointCode parameter has wrong length %dn",parmlen);
  1123.    if ((checkchangelog(log,lognamn))==0)
  1124.                                                           n2log(log,msg);
  1125.                                                 break;
  1126.                                         }
  1127.                                         x+=parmlen;
  1128. #ifdef SETDBG
  1129. puts("DPC");
  1130. #endif
  1131. check = MyOperation->setValue("DPC",(char*)&tmpcdrptr->DestinationPointCode);
  1132. if (check == -1)
  1133. error_handler(MyTransaction->getNdbErrorString());
  1134.                                 break;
  1135.                                 case 255:       /* CircuitIdentificationCode */
  1136.                                         swab(buf+x,buf+x,2);
  1137.                                         memcpy(&tmpcdrptr->CircuitIdentificationCode,(buf+x),2);
  1138.                                         tmpcdrptr->USED_FIELDS |= B_CircuitIdentificationCode;
  1139.                                         x+=parmlen;
  1140. #ifdef SETDBG
  1141. puts("CIC");
  1142. #endif
  1143. check = MyOperation->setValue("CIC",(char*)&tmpcdrptr->CircuitIdentificationCode);
  1144. if (check == -1)
  1145. error_handler(MyTransaction->getNdbErrorString());
  1146.                                 break;
  1147.                                 default:
  1148.                                         printf("ERROR: Undefined parmtype %d , previous %d, length %dn",parmtype,parmtype_prev,parmlen);
  1149.                                         BaseString::snprintf(msg,sizeof(msg),"ERROR: Undefined parmtype %d , previous %d, length %dn",parmtype,parmtype_prev,parmlen);
  1150.    if ((checkchangelog(log,lognamn))==0)
  1151.                                           n2log(log,msg);
  1152.                                         if (parmlen == 0) {
  1153.                                                 x++;
  1154.                                         }
  1155.                                         x+=parmlen;
  1156.                                 break;
  1157.                         }
  1158.                         parmtype_prev=parmtype;
  1159.                         if ((cdrrestlen-x) == 1) {
  1160.                                 done=TRUE;
  1161.                         }
  1162.                 }
  1163. time(&ourtime);
  1164. if (ourtime != tmptime)
  1165. {
  1166. transfer = tmptransfer;
  1167. tmptransfer = 0;
  1168. if (++act_index == 30)
  1169. {
  1170. act_index = 0;
  1171. printf("Transfer=%dn",transfer);
  1172. printf("Total operations=%dn",reqcnt);
  1173. printf("CAS1=%dn",c1/30);
  1174. printf("CAS2=%dn",c2/30);
  1175. printf("CAS3=%dn",c3/30);
  1176. c1=0;
  1177. c2=0;
  1178. c3=0;
  1179. }
  1180. tmptime = ourtime;
  1181. }
  1182.                 switch (cdrsubtype) {
  1183.                         case 0:
  1184.                                 tmpcdrptr->ClientId = servernum;
  1185. #ifdef SETDBG
  1186. puts("ClientId");
  1187. #endif
  1188. check = MyOperation->setValue("ClientId",(char*)&tmpcdrptr->ClientId);
  1189. if (check == -1)
  1190. error_handler(MyTransaction->getNdbErrorString());
  1191.                                 tmpcdrptr->OurSTART_TIME = ourtime;
  1192. #ifdef SETDBG
  1193. puts("OurSTART_TIME");
  1194. #endif
  1195. check = MyOperation->setValue("OurSTART_TIME",(char*)&tmpcdrptr->OurSTART_TIME);
  1196. if (check == -1)
  1197. error_handler(MyTransaction->getNdbErrorString());
  1198.                                 tmpcdrptr->USED_FIELDS |= B_START_TIME;
  1199. #ifdef SETDBG
  1200. puts("USED_FIELDS");
  1201. #endif
  1202. check = MyOperation->setValue("USED_FIELDS",(char*)&tmpcdrptr->USED_FIELDS);
  1203. if (check == -1)
  1204. error_handler(MyTransaction->getNdbErrorString());
  1205.                         break;
  1207.                         case 1:
  1208.                                 tmpcdrptr->OurTimeForStartOfCharge = ourtime;
  1209. #ifdef SETDBG
  1210. puts("OurStartOfCharge");
  1211. #endif
  1212. check = MyOperation->setValue("OurStartOfCharge",(char*)&tmpcdrptr->OurTimeForStartOfCharge);
  1213. if (check == -1)
  1214. error_handler(MyTransaction->getNdbErrorString());
  1215.                                 tmpcdrptr->USED_FIELDS |= B_TimeForStartOfCharge;
  1216. #ifdef SETDBG
  1217. puts("USED_FIELDS");
  1218. #endif
  1219. check = MyOperation->setValue("USED_FIELDS",(char*)&tmpcdrptr->USED_FIELDS);
  1220. if (check == -1)
  1221. error_handler(MyTransaction->getNdbErrorString());
  1222.                         break;
  1224.                         case 2:
  1225.                                 tmpcdrptr->OurTimeForStopOfCharge = ourtime;
  1226. #ifdef SETDBG
  1227. puts("OurStopOfCharge");
  1228. #endif
  1229. check = MyOperation->setValue("OurStopOfCharge",(char*)&tmpcdrptr->OurTimeForStopOfCharge);
  1230. if (check == -1)
  1231. error_handler(MyTransaction->getNdbErrorString());
  1232.                                 tmpcdrptr->USED_FIELDS |= B_TimeForStopOfCharge;
  1233. #ifdef SETDBG
  1234. puts("USED_FIELDS");
  1235. #endif
  1236. check = MyOperation->setValue("USED_FIELDS",(char*)&tmpcdrptr->USED_FIELDS);
  1237. if (check == -1)
  1238. error_handler(MyTransaction->getNdbErrorString());
  1239.                         break;
  1241.                         case 3:
  1242.                                 tmpcdrptr->CallAttemptState  = 4;
  1243.                         break;
  1244. default:
  1245.          snprintf(msg,sizeof(msg),"cdrtype %d unknown",cdrsubtype);
  1246. if ((checkchangelog(log,lognamn))==0)
  1247.            n2log(log,msg);
  1248.                                 goto errout;
  1249.                         break;
  1250.                 }
  1251.                                 ops++;
  1252.                                 if (ops == ops_before_exe) {
  1253.                                   ops = 0;
  1254.                                   #ifdef SETDBG
  1255.                                         puts("Going to execute");
  1256.                                   #endif
  1257.                                   check = MyTransaction->execute(Commit, CommitAsMuchAsPossible);
  1258.                    if ((check == -1) && (MyTransaction->getNdbError() != 0))
  1259.                                         error_handler(MyTransaction->getNdbErrorString());
  1260.                                   MyNdb.closeTransaction(MyTransaction);
  1261.                                   #ifdef SETDBG
  1262.                                         puts("Transaction closed");
  1263.                                   #endif
  1265.                                   #ifdef SETDBG
  1266.                                         puts("New transaction initiated");
  1267.                                   #endif
  1268.                                 }//if
  1269.                 /* Increment the request count. */
  1270.                 reqcnt++;
  1272.                 /* Send a response back to the client. */
  1274.                 /* if (send(s, buf, 10, 0) != 10) goto errout;  */
  1275.         }
  1277.         /* The loop has terminated, because there are no                */
  1278.         /* more requests to be serviced. As mentioned above,            */
  1279.         /* this close will block until all of the sent replies          */
  1280.         /* have been received by the remote host. The reason            */
  1281.         /* for lingering on the close is so that the server will        */
  1282.         /* have a better idea of when the remote has picked up          */
  1283.         /* all of the data. This will allow the start and finish        */
  1284.         /* times printed in the log file to reflect more accurately     */
  1285.         /* the length of time this connection was                       */
  1286.         /* The port number must be converted first to host byte         */
  1287.         /* order before printing. On most hosts, this is not            */
  1288.         /* necessary, but the ntohs() call is included here so          */
  1289.         /* that this program could easily be ported to a host           */
  1290.         /* that does require it.                                        */
  1292.         BaseString::snprintf(msg,sizeof(msg),"Completed %s port %u, %d requests",hostname,ntohs(peeraddr_in.sin_port), reqcnt);
  1293. if ((checkchangelog(fi,temp))==0)
  1294.           c2log(fi,msg);
  1295. error_from_client = 1;
  1296.         BaseString::snprintf(msg,sizeof(msg),"Communicate with threads");
  1297. if ((checkchangelog(log,lognamn))==0)
  1298.           n2log(log,msg);
  1299.         BaseString::snprintf(msg,sizeof(msg),"Waiting for threads to return from work");
  1300. if ((checkchangelog(log,lognamn))==0)
  1301.           n2log(log,msg);
  1302.         BaseString::snprintf(msg,sizeof(msg),"Closing down");
  1303. if ((checkchangelog(log,lognamn))==0)
  1304.           n2log(log,msg);
  1305.         close(s);
  1306.         fclose(log);
  1307.         return EXIT_SUCCESS;
  1309. errout:
  1310.         BaseString::snprintf(msg,sizeof(msg),"Connection with %s aborted on errorn", hostname);
  1311. if ((checkchangelog(log,lognamn))==0)
  1312.           n2log(log,msg);
  1313. if ((checkchangelog(fi,temp))==0)
  1314.           c2log(fi,msg);
  1315. error_from_client = 1;
  1316.         BaseString::snprintf(msg,sizeof(msg),"Communicate with threads");
  1317. if ((checkchangelog(log,lognamn))==0)
  1318.           n2log(log,msg);
  1319.         BaseString::snprintf(msg,sizeof(msg),"Waiting for threads to return from work");
  1320. if ((checkchangelog(log,lognamn))==0)
  1321.           n2log(log,msg);
  1322.         BaseString::snprintf(msg,sizeof(msg),"Closing down");
  1323. if ((checkchangelog(log,lognamn))==0)
  1324.           n2log(log,msg);
  1325.         close(s);
  1326.         fclose(log);
  1327. return EXIT_FAILURE;
  1328. }
  1330. void
  1331. create_table(Ndb* pMyNdb)
  1332. {
  1334.  /****************************************************************
  1335.    *    Create table and attributes.
  1336.    *
  1337.    *    create table basictab1(
  1338.    *        col1 int,
  1339.    *        col2 int not null,
  1340.    *        col3 int not null,
  1341.    *        col4 int not null
  1342.    *     )
  1343.    * 
  1344.    ***************************************************************/
  1346.   int                   check;
  1347.   int                   i;
  1348.   NdbSchemaCon          *MySchemaTransaction;
  1349.   NdbSchemaOp           *MySchemaOp;
  1350.   int tAttributeSize;
  1352.   tAttributeSize = 1;
  1354.   cout << "Creating " << tableName << "..." << endl;
  1356.    MySchemaTransaction = pMyNdb->startSchemaTransaction();
  1357.    if( MySchemaTransaction == NULL )
  1358.       error_handler(MySchemaTransaction->getNdbErrorString());
  1360.    MySchemaOp = MySchemaTransaction->getNdbSchemaOp();
  1361.    if( MySchemaOp == NULL )
  1362.       error_handler(MySchemaTransaction->getNdbErrorString());
  1364.    // Createtable
  1365.    check = MySchemaOp->createTable( tableName,
  1366.                                      8,         // Table Size
  1367.                                      TupleKey,  // Key Type
  1368.                                      40         // Nr of Pages
  1369.                                    );
  1370.    if( check == -1 )
  1371.       error_handler(MySchemaTransaction->getNdbErrorString());
  1373.    // CallIdentificationNumber Create first column, primary key 
  1374.    check = MySchemaOp->createAttribute( "CIN", 
  1375. TupleKey, 
  1376. 32,
  1377.                                         tAttributeSize,
  1378. UnSigned, MMBased,
  1379.                                         NotNullAttribute 
  1380. );
  1381.    if( check == -1 )
  1382.       error_handler(MySchemaTransaction->getNdbErrorString());
  1383.   
  1385.    // USED_FIELDS Create attributes
  1386.    check = MySchemaOp->createAttribute( "USED_FIELDS", NoKey, 32,
  1387.                                          tAttributeSize, UnSigned, MMBased,
  1388.                                          NullAttribute );
  1389.    if( check == -1 )
  1390.       error_handler(MySchemaTransaction->getNdbErrorString());
  1391.  
  1392.    // ClientId Create attributes
  1393.    check = MySchemaOp->createAttribute( "ClientId", NoKey, 32,
  1394.                                          tAttributeSize, UnSigned, MMBased,
  1395.                                          NullAttribute );
  1396.    if( check == -1 )
  1397.       error_handler(MySchemaTransaction->getNdbErrorString());
  1398.  
  1399.    // START_TIME Create attributes
  1400.    check = MySchemaOp->createAttribute( "START_TIME", NoKey, 32,
  1401.                                          tAttributeSize, UnSigned, MMBased,
  1402.                                          NullAttribute );
  1403.    if( check == -1 )
  1404.       error_handler(MySchemaTransaction->getNdbErrorString());
  1405.  
  1406.    // OurSTART_TIME Create attributes
  1407.    check = MySchemaOp->createAttribute( "OurSTART_TIME", NoKey, 32,
  1408.                                          tAttributeSize, UnSigned, MMBased,
  1409.                                          NullAttribute );
  1410.    if( check == -1 )
  1411.       error_handler(MySchemaTransaction->getNdbErrorString());
  1412.  
  1413.    // TimeForStartOfCharge Create attributes
  1414.    check = MySchemaOp->createAttribute( "StartOfCharge", NoKey, 32,
  1415.                                          tAttributeSize, UnSigned, MMBased,
  1416.                                          NullAttribute );
  1417.    if( check == -1 )
  1418.       error_handler(MySchemaTransaction->getNdbErrorString());
  1419.  
  1420.    // TimeForStopOfCharge Create attributes
  1421.    check = MySchemaOp->createAttribute( "StopOfCharge", NoKey, 32,
  1422.                                          tAttributeSize, UnSigned, MMBased,
  1423.                                          NullAttribute );
  1424.    if( check == -1 )
  1425.       error_handler(MySchemaTransaction->getNdbErrorString());
  1426.  
  1427.    // OurTimeForStartOfCharge Create attributes
  1428.    check = MySchemaOp->createAttribute( "OurStartOfCharge", NoKey, 32,
  1429.                                          tAttributeSize, UnSigned, MMBased,
  1430.                                          NullAttribute );
  1431.    if( check == -1 )
  1432.       error_handler(MySchemaTransaction->getNdbErrorString());
  1433.  
  1434.    // OurTimeForStopOfCharge Create attributes
  1435.    check = MySchemaOp->createAttribute( "OurStopOfCharge", NoKey, 32,
  1436.                                          tAttributeSize, UnSigned, MMBased,
  1437.                                          NullAttribute );
  1438.    if( check == -1 )
  1439.       error_handler(MySchemaTransaction->getNdbErrorString());
  1440.  
  1441.    // DestinationPointCode Create attributes
  1442.    check = MySchemaOp->createAttribute( "DPC", NoKey, 16,
  1443.                                          tAttributeSize, UnSigned, MMBased,
  1444.                                          NullAttribute );
  1445.    if( check == -1 )
  1446.       error_handler(MySchemaTransaction->getNdbErrorString());
  1447.  
  1448.    // OriginatingPointCode Create attributes
  1449.    check = MySchemaOp->createAttribute( "OPC", NoKey, 16,
  1450.                                          tAttributeSize, UnSigned, MMBased,
  1451.                                          NullAttribute );
  1452.    if( check == -1 )
  1453.       error_handler(MySchemaTransaction->getNdbErrorString());
  1454.  
  1455.    // CircuitIdentificationCode Create attributes
  1456.    check = MySchemaOp->createAttribute( "CIC", NoKey, 16,
  1457.                                          tAttributeSize, UnSigned, MMBased,
  1458.                                          NullAttribute );
  1459.    if( check == -1 )
  1460.       error_handler(MySchemaTransaction->getNdbErrorString());
  1461.  
  1462.    // ReroutingIndicator Create attributes
  1463.    check = MySchemaOp->createAttribute( "RI", NoKey, 16,
  1464.                                          tAttributeSize, UnSigned, MMBased,
  1465.                                          NullAttribute );
  1466.    if( check == -1 )
  1467.       error_handler(MySchemaTransaction->getNdbErrorString());
  1468.  
  1469.    // RINParameter Create attributes
  1470.    check = MySchemaOp->createAttribute( "RINParameter", NoKey, 16,
  1471.                                          tAttributeSize, UnSigned, MMBased,
  1472.                                          NullAttribute );
  1473.    if( check == -1 )
  1474.       error_handler(MySchemaTransaction->getNdbErrorString());
  1475.  
  1476.    // NetworkIndicator Create attributes
  1477.    check = MySchemaOp->createAttribute( "NIndicator", NoKey, 8,
  1478.                                          tAttributeSize, Signed, MMBased,
  1479.                                          NullAttribute );
  1480.    if( check == -1 )
  1481.       error_handler(MySchemaTransaction->getNdbErrorString());
  1482.  
  1483.    // CallAttemptState Create attributes
  1484.    check = MySchemaOp->createAttribute( "CAS", NoKey, 8,
  1485.                                          tAttributeSize, Signed, MMBased,
  1486.                                          NullAttribute );
  1487.    if( check == -1 )
  1488.       error_handler(MySchemaTransaction->getNdbErrorString());
  1489.  
  1490.    // ACategory Create attributes
  1491.    check = MySchemaOp->createAttribute( "ACategory", NoKey, 8,
  1492.                                          tAttributeSize, Signed, MMBased,
  1493.                                          NullAttribute );
  1494.    if( check == -1 )
  1495.       error_handler(MySchemaTransaction->getNdbErrorString());
  1496.  
  1497.    // EndOfSelectionInformation Create attributes
  1498.    check = MySchemaOp->createAttribute( "EndOfSelInf", NoKey, 8,
  1499.                                          tAttributeSize, Signed, MMBased,
  1500.                                          NullAttribute );
  1501.    if( check == -1 )
  1502.       error_handler(MySchemaTransaction->getNdbErrorString());
  1503.  
  1504.    // UserToUserInformation Create attributes
  1505.    check = MySchemaOp->createAttribute( "UserToUserInf", NoKey, 8,
  1506.                                          tAttributeSize, Signed, MMBased,
  1507.                                          NullAttribute );
  1508.    if( check == -1 )
  1509.       error_handler(MySchemaTransaction->getNdbErrorString());
  1510.  
  1511.    // UserToUserIndicator Create attributes
  1512.    check = MySchemaOp->createAttribute( "UserToUserInd", NoKey, 8,
  1513.                                          tAttributeSize, Signed, MMBased,
  1514.                                          NullAttribute );
  1515.    if( check == -1 )
  1516.       error_handler(MySchemaTransaction->getNdbErrorString());
  1517.  
  1518.    // CauseCode Create attributes
  1519.    check = MySchemaOp->createAttribute( "CauseCode", NoKey, 8,
  1520.                                          tAttributeSize, Signed, MMBased,
  1521.                                          NullAttribute );
  1522.    if( check == -1 )
  1523.       error_handler(MySchemaTransaction->getNdbErrorString());
  1524.  
  1525.    // ASubscriberNumber attributes
  1526.    check = MySchemaOp->createAttribute( "ANumber", NoKey, 8,
  1527.                                          ASubscriberNumber_SIZE, Signed, MMBased,
  1528.                                          NullAttribute );
  1529.    if( check == -1 )
  1530.       error_handler(MySchemaTransaction->getNdbErrorString());
  1531.  
  1532.    // ASubscriberNumberLenght attributes
  1533.    check = MySchemaOp->createAttribute( "ANumberLength", NoKey, 8,
  1534.                                          tAttributeSize, Signed, MMBased,
  1535.                                          NullAttribute );
  1536.    if( check == -1 )
  1537.       error_handler(MySchemaTransaction->getNdbErrorString());
  1538.  
  1539.    // TonASubscriberNumber attributes
  1540.    check = MySchemaOp->createAttribute( "TonANumber", NoKey, 8,
  1541.                                          tAttributeSize, Signed, MMBased,
  1542.                                          NullAttribute );
  1543.    if( check == -1 )
  1544.       error_handler(MySchemaTransaction->getNdbErrorString());
  1545.  
  1546.    // BSubscriberNumber attributes
  1547.    check = MySchemaOp->createAttribute( "BNumber", NoKey, 8,
  1548.                                          BSubscriberNumber_SIZE, Signed, MMBased,
  1549.                                          NullAttribute );
  1550.    if( check == -1 )
  1551.       error_handler(MySchemaTransaction->getNdbErrorString());
  1552.  
  1553.    // BSubscriberNumberLength attributes
  1554.    check = MySchemaOp->createAttribute( "BNumberLength", NoKey, 8,
  1555.                                          tAttributeSize, Signed, MMBased,
  1556.                                          NullAttribute );
  1557.    if( check == -1 )
  1558.       error_handler(MySchemaTransaction->getNdbErrorString());
  1559.  
  1560.    // TonBSubscriberNumber attributes
  1561.    check = MySchemaOp->createAttribute( "TonBNumber", NoKey, 8,
  1562.                                          tAttributeSize, Signed, MMBased,
  1563.                                          NullAttribute );
  1564.    if( check == -1 )
  1565.       error_handler(MySchemaTransaction->getNdbErrorString());
  1566.  
  1567.    // RedirectingNumber attributes
  1568.    check = MySchemaOp->createAttribute( "RNumber", NoKey, 8,
  1569.                                          ASubscriberNumber_SIZE, Signed, MMBased,
  1570.                                          NullAttribute );
  1571.    if( check == -1 )
  1572.       error_handler(MySchemaTransaction->getNdbErrorString());
  1573.  
  1574.    // TonRedirectingNumber attributes
  1575.    check = MySchemaOp->createAttribute( "TonRNumber", NoKey, 8,
  1576.                                          tAttributeSize, Signed, MMBased,
  1577.                                          NullAttribute );
  1578.    if( check == -1 )
  1579.       error_handler(MySchemaTransaction->getNdbErrorString());
  1580.  
  1581.    // OriginalCalledNumber attributes
  1582.    check = MySchemaOp->createAttribute( "ONumber", NoKey, 8,
  1583.                                          ASubscriberNumber_SIZE, Signed, MMBased,
  1584.                                          NullAttribute );
  1585.    if( check == -1 )
  1586.       error_handler(MySchemaTransaction->getNdbErrorString());
  1587.  
  1588.    // TonOriginalCalledNumber attributes
  1589.    check = MySchemaOp->createAttribute( "TonONumber", NoKey, 8,
  1590.                                          tAttributeSize, Signed, MMBased,
  1591.                                          NullAttribute );
  1592.    if( check == -1 )
  1593.       error_handler(MySchemaTransaction->getNdbErrorString());
  1594.  
  1595.    // LocationCode attributes
  1596.    check = MySchemaOp->createAttribute( "LocationCode", NoKey, 8,
  1597.                                          ASubscriberNumber_SIZE, Signed, MMBased,
  1598.                                          NullAttribute );
  1599.    if( check == -1 )
  1600.       error_handler(MySchemaTransaction->getNdbErrorString());
  1601.  
  1602.    // TonLocationCode attributes
  1603.    check = MySchemaOp->createAttribute( "TonLocationCode", NoKey, 8,
  1604.                                          tAttributeSize, Signed, MMBased,
  1605.                                          NullAttribute );
  1606.    if( check == -1 )
  1607.       error_handler(MySchemaTransaction->getNdbErrorString());
  1608.  
  1609.    if( MySchemaTransaction->execute() == -1 ) {
  1610.        cout << tableName << " already exist" << endl;
  1611.        cout << "Message: " << MySchemaTransaction->getNdbErrorString() << endl;
  1612.    }
  1613.    else
  1614.    {
  1615.      cout << tableName << " created" << endl;
  1616.    }
  1617.    pMyNdb->closeSchemaTransaction(MySchemaTransaction);
  1618.   
  1619.    return;
  1620. }
  1622. void
  1623. error_handler(const char* errorText)
  1624. {
  1625.   // Test failed
  1626.   cout << endl << "ErrorMessage: " << errorText << endl;
  1627.   bTestPassed = -1;
  1628. }