C/Visual C - ayuda en ejercicio de pacientes

include<stdio.h>

#include <stdlib.h>

#include <iostream>

int NA;

char ap,nom,os,serv;

float vc;

 main ()

{

system("cls");

printf("\n ingresar el nro de atención:\n");

scanf("%d",&NA);

printf("\ningresar Apellido del paciente:\n");

scanf("%s",&ap);

printf("\ningresar nombre del paciente:\n");

scanf("%s",&nom);

printf("ingresar el servicio en el que se atenderá:\n");

scanf("%s",&serv);

printf("\ningresar nombre de la obra social que presenta:\n");

scanf("%s",&os);

printf("\ningresar valor de la consulta:\n");

scanf("%f",&vc);

mientras (verdadero)

    si (numeroAtencion == 0)

        salir = falso

    sino

        <siguientes instrucciones>

    fin-si

fin-mientras

#include <stdlib.h>

#include <stdio.h>

int main() {

	//variables

		//na: numero de atencion

		//serv: servicio en el que se atendera

		//ap,nom: apellidos y nombres

		//os: Obras Sociales

		//Valor de la consulta

	int na,flag=1;

	char serv[35],ap[40],nom[40],os[40];

	float vc;

	while (flag) {

		printf("Ingrese el numero de atencion: ");

		scanf("%d",&na);

		if (na == 0)

			flag = 0;

		else {

			printf("Ingresar apellido de paciente: ");

			scanf(" %s",ap);

			printf("Ingresar nombre de paciente: ");

			scanf(" %s",nom);

			printf("Ingresar el servicio en el que se atendera: ");

			scanf(" %s",serv);

			printf("Ingresar nombre de la obra social que presenta: ");

			scanf(" %s",&os);

			printf("Ingresar valor de la consulta: ");

			scanf("%f",&vc);

		}

	}

	return 0;

}

SOCKET      ServerSocket = 0;

     SOCKET      ClientSocket = 0;

     struct      sockaddr_in    ServerInetAddress = { 0,0,0,0};

     struct      linger linger = { 0 , 0 };

     long        InetAddressLen = sizeof(ServerInetAddress);

     int         port      = 1919,

                 nLen      = 0,

                 i         = 0;

     int         bNoDelay  = 1;

     int         nRetVal   = 0;

     int         nSysProcd = 0;

     char        ccRegLog[LMAX_MSGE]    = {0x00};

     char        scCadena[LMAX_MSGE]    = {0x00};

     char        cCadena [LMAX_MSGE]    = {0x00};

     char       *pCadena                = cCadena;

     char        cJclLoganet[LMAX_MSGE] = {0x00};

     char        cJclNEWERAC[LMAX_CMND]  = {0x00};

     char        cJclNSA[LMAX_CMND]     = {0x00};

     char        cJclMIRESIN[LMAX_CMND]   = {0x00};

     char        cLoganetLog[LMAX_RESP] = {0x00} ;

     char        cNEWERACLog[LMAX_RESP]  = {0x00} ;

     char        cNSALog[LMAX_RESP]     = {0x00} ;

     char        cMIRESINLog[LMAX_RESP]   = {0x00} ;

     char        cLoganetRta[LMAX_RESP] = {0x00} ;

     char        cNEWERACRta[LMAX_RESP]  = {0x00} ;

     char        cNSARta[LMAX_RESP]     = {0x00} ;

     char        cMIRESINRta[LMAX_RESP]   = {0x00} ;

     char        ccResp[LMAX_RESP]      = {0x00};

     char        cAsunto[LMAX_TITU]     = {0x00} ;

     int        iConLoganet     = 0;

     int         iConNEWERAC      = 0;

     int         iConNSA         = 0;

     int         iConMIRESIN       = 0;

     int         iCblo           = 0;

     int         idErroneos      = 0;

     int         ioErroneos      = 0;

     int         EstoyActivo     = 1;

     char        ccVeinte[10];

     pthread_t   thread_id;

     time_t RawTime;

     char ccRawTime[25]      = {0x00} ;

     char cDreamTeam[LDES_MAIL]   = "micaela.varela@ar.galicia.com,jorge.luis.gallo@ar.galicia.com";

     char cCapitMarket[LDES_MAIL] = "ga.grupo11.market@ar.galicia.com,bernard.carnesa@ar.galicia.com";

     char cARBOTrade[LDES_MAIL] = "ga.grupo13.office@ar.galicia.com,comessta.gorello@ar.galicia.com";

     /*--------------------------------------------*\

     * Programa de Escucha de Transacciones ONLINE  *

     \*--------------------------------------------*/

     Presentacion() ;

     /* Verify program's argument count */

     if( argc < 1 )

     {

          printf("Error de argumentos\r\n");

          printf("Sintaxis: o_proyama2 \r\n");

          nRetVal = system( "proyam82 MAIL" );

          exit(FAILURE);

     }

     /*--------------------------------------------------*\

      *  Allocate the server's socket descriptor         *

     \*--------------------------------------------------*/

     if  ((ServerSocket = socket(AF_INET,SOCK_STREAM, 0)) == FAILURE)

     {

          printf("Error de creacion del socket\r\n");

          nRetVal = system( "proyam82 MAIL" );

          exit(FAILURE);

     }

     printf("Socket creado\r\n");

     /*--------------------------------------------------*\

      *  Set the linger option to force immediate closing*

     \*--------------------------------------------------*/

     linger.l_onoff  = 1; /* turn on timer     */

     linger.l_linger = 0; /* close immediately */

     if  ((setsockopt(ServerSocket, SOL_SOCKET, SO_LINGER,

                     (char *)(&linger), sizeof(linger))) == FAILURE)

     {

           printf("Error de opcion sobre el socket - linger\r\n");

           nRetVal = system( "proyam82 MAIL" );

           exit(FAILURE);

     }

     /*--------------------------------------------------*\

      *  Don't buffer up requests - send them immediately*

     \*--------------------------------------------------*/

     if  ((setsockopt(ServerSocket, IPPROTO_TCP, TCP_NODELAY, (char *)(&bNoDelay), sizeof(bNoDelay))) == FAILURE)

     {

          printf("Error de creacion del socket - delay\r\n");

          nRetVal = system( "proyam82 MAIL" );

          exit(FAILURE);

     }

     GetNameLoganetLog(cLoganetLog);

     GetNameNEWERACLog(cNEWERACLog);

     GetNameNSALog(cNSALog);

     GetNameMIRESINLog(cMIRESINLog);

     printf("LOG Loganet \t %s \n", cLoganetLog) ;

     printf("LOG NEWERAC  \t %s \n", cNEWERACLog) ;

     printf("LOG NSA     \t %s \n", cNSALog) ;

     printf("LOG MIRESIN   \t %s \n", cMIRESINLog) ;

     /*---------------------------------------------------*\

      printf("Elimina LOGs de NEWERAC y Loganet\n");

      EliminaLogs(cLoganetLog);

      EliminaLogs(cNEWERACLog);

     \*---------------------------------------------------*/

     printf("***************************************************************************\r\n");

     printf("Programa de Escucha de Transacciones ONLINE\r\n");

     GetNameLoganetResp(cLoganetRta);

     GetNameNEWERACResp(cNEWERACRta);

     GetNameNSAResp(cNSARta);

     GetNameMIRESINResp(cMIRESINRta);

     /*--------------------------------------------------*\

     *  Initialize the socket address so we can bind it   *

     \*--------------------------------------------------*/

     /*

      |

      |  port = atoi(argv[1]);

      |  ---------------------

      */

     memset(&ServerInetAddress, 0x00, sizeof(ServerInetAddress));

     ServerInetAddress.sin_family      = AF_INET;

     ServerInetAddress.sin_addr.s_addr = INADDR_ANY; /* Let anyone connect  */

     ServerInetAddress.sin_port        = htons(port);

     /*------------------------------------------*\

     * Bind socket to the well-known port number  *

     \*------------------------------------------*/

     if (bind(ServerSocket, (struct sockaddr*)&ServerInetAddress, sizeof(ServerInetAddress)) == FAILURE)

     {

         printf("Error de enlace al socket\r\n");

         nRetVal = system( "proyam82 MAIL" );

         exit(FAILURE);

     }

     /*--------------------------------------------------*\

      * Show we are willing to listen                    *

     \*--------------------------------------------------*/

     if (listen(ServerSocket, 1) == FAILURE) {

         printf("Error de escucha sobre el socket\r\n");

         nRetVal = system( "proyam82 MAIL" );

         exit(FAILURE);

     }

     EstoyActivo=1;

     while ( EstoyActivo ) {

          printf("Escuchando...\r\n");

          if ((ClientSocket = accept(ServerSocket , (struct sockaddr*)&ServerInetAddress,(socklen_t *)&InetAddressLen)) == FAILURE) {

               printf("Error de aceptacion sobre el socket\r\n");

               nRetVal = system( "proyam82 MAIL" );

               exit(FAILURE);

          }

          printf("Conexion cliente aceptada:(%i)\r\n",ClientSocket);

          nRetVal = pthread_create(&thread_id, NULL, NewProcess, (void *) ClientSocket);

          if (result != 0) {

               printf("No Puedo crear Thread.\n");

          }

          pthread_detach(thread_id);

          sched_yield();

     }

     /*---------------------------------------------------*\

      * CLOSE THE SERVER CONNECTION - ONLY WHEN NO MORE   *

      * CONNECTION REQUESTS WILL BE ACCEPTED              *

     \*---------------------------------------------------*/

     close(ServerSocket);

     ServerSocket = 0;

     printf("Fin de programa\r\n");

     return 0;

}

         /*

           printf("Conexion cliente aceptada:(%i)\r\n",ClientSocket);

          */

         /*---------------------------------*\

          *  Recibe data from the client   *

         \*---------------------------------*/

         memset( scCadena, '\0', sizeof(scCadena));

         memset(  cCadena, '\0', sizeof( cCadena));

         if ((nLen=Recibe(ClientSocket, scCadena, sizeof(scCadena)-1)) < 0) {

              close(ClientSocket);

              ClientSocket = 0;

              printf("Conexion cliente cerrada\r\n");

              nRetVal = system( "proyam82 ERROR" );

              continue ;

         } else {

             /*

              | printf("acabo de recibir:(%s)\r\n", scCadena);

              |

              | printf("time:%d\n", RawTime );

              | printf("%s", ctime(&RawTime));

              |

              */

             memset(ccRawTime, '\0', sizeof(ccRawTime));

             time(&RawTime);

             sprintf(ccRawTime,"%s", ctime( &RawTime ) );

             /* printf("Recv of Time:  %s\n", ccRawTime);  */

             memset(ccRegLog, '\0', sizeof(ccRegLog));

             rtrim( cCadena, scCadena );

             pCadena = cCadena ;

             /*  printf("%s \r\n", cCadena);   */

             memcpy(scCadena, cCadena, LMAX_MSGE );

             sprintf(ccRegLog, "%s  : %s\n", cCadena , ccRawTime );

             printf("%s \r\n", ccRegLog);

             memcpy(scCadena, cCadena, LMAX_MSGE );

             nSysProcd=GetProcedencia( cCadena );

             switch (nSysProcd)

             {

             case IS_Loganet:

                    memset(cJclLoganet, '\0', sizeof(cJclLoganet));

                    strncpy(cJclLoganet,"proyam82 ",7) ;

                    /*-------------------------------------------------*\

                     *       PONE DELIMTADOR DE DOBLES COMILLAS        *

                    \*-------------------------------------------------*/

                    strcat( cJclLoganet, "\"") ;

                    strcat( cJclLoganet, cCadena) ;

                    /* strncat( cJclLoganet, "\"", 157) ; */

                    strncat( cJclLoganet, "\"", 213) ;

                    /*-------------------------------------------------*\

                     *       EJECUTA EL JCL SELECCIONADO               *

                    \*-------------------------------------------------*/

                    nRetVal = system( cJclLoganet ) ;

                    memset( ccResp, '\0', sizeof(ccResp));

                    GetRespuestaLoganet(ccResp, cLoganetRta);

                    if (send(ClientSocket, ccResp, strlen(ccResp), 0) == FAILURE)

                    {

                         close(ClientSocket);

                         ClientSocket = 0;

                         nRetVal = system( "proyam82 ERROR" );

                    }

                    iConLoganet=iConLoganet+1;

                    /*

                     | Se cambia el grabado del log

                     | anulado GrabaLogs(cLoganetLog, cCadena, ccResp) ;

                     */

                    GrabaLogs(cLoganetLog, ccRegLog, ccResp) ;

                    iCblo=0;

                    iCblo=GetCodigoRespuesta(ccResp);

                    if(iCblo Equ 002 Or iCblo Equ 110 Or iCblo Equ 104 Or iCblo Equ 105 Or \

                       iCblo Equ 106 Or iCblo Equ 107 Or iCblo Equ 108 Or iCblo Equ 113 Or \

                       iCblo Equ 114 Or iCblo Equ 120 Or iCblo Equ 999)

                    {

                         /* printf("Retorno Cblo ...: %i \n", iCblo); */

                         idErroneos = idErroneos + 1 ;

                         /*                        */

                         GetAsuntoMail( cAsunto, ccResp);

                         SaveBodyLoganet(cCadena, ccResp, cAsunto);

                         SendMailLoganet(cAsunto, cDreamTeam) ;

                         if(iCblo Equ 120)

                         {

                             strncpy(ccVeinte, ccResp, 3);

                             ccVeinte[3] = '\0';

                             nRetVal = pthread_create(&thread_id, NULL, ProcesoHijitus, (void *) ccVeinte);

                             if (nRetVal != 0)

                                  printf("No Puedo crear Thread para enviar el mail\n");

                             /*------------------------------------------------------------------------------------------*\

                              * La función pthread_detach() marca el hilo identificado por hilo como individual.

                              *  Cuando un hilo individual termina, sus recursos se liberan automáticamente

                              *  al sistema sin la necesidad de otro hilo para unirse con el hilo terminado.

                             \*------------------------------------------------------------------------------------------*/

                             nRetVal = pthread_detach(thread_id) ;

                             if ( nRetVal != 0 )

                             {

                                  printf("Auch!! resultado no esperado! rc=%d\n", nRetVal );

                             }

                         }

                    }

                    break;

             case IS_NEWERAC:

                    memset(cJclNEWERAC, '\0', sizeof(cJclNEWERAC));

                    strncpy(cJclNEWERAC,"proyam84 ",7) ;

                    /*--------------------------------------------*\

                     *       PONE DELIMTADOR DE DOBLES COMILLAS   *

                    \*--------------------------------------------*/

                    strcat( cJclNEWERAC, "\"") ;

                    strcat( cJclNEWERAC, cCadena) ;

                    /* strncat( cJclNEWERAC, "\"", 157 ) ;

                    strncat( cJclNEWERAC, "\"", 213 ) ;

                    /* printf("Shell: %s \r\n", cJclNEWERAC) ; */

                    /*--------------------------------------------*\

                     *       EJECUTA EL JCL SELECCIONADO          *

                    \*--------------------------------------------*/

                    nRetVal = system( cJclNEWERAC ) ;

                    memset( ccResp, '\0', sizeof(ccResp));

                    GetRespuestaNEWERAC(ccResp, cNEWERACRta);

                    if (send(ClientSocket, ccResp, strlen(ccResp), 0) == FAILURE)

                    {

                         close(ClientSocket) ;

                         ClientSocket = 0 ;

                         nRetVal = system( "proyam84 ERROR" ) ;

                    }

                    iConNEWERAC=iConNEWERAC+1;

                    /*

                     | Se cambia el grabado del log

                     | anulado GrabaLogs(cNEWERACLog, cCadena, ccResp) ;

                     */

                    GrabaLogs(cNEWERACLog, ccRegLog, ccResp) ;

                    iCblo=0;

                    iCblo=GetCodigoRespuesta(ccResp);

                    if(iCblo Equ 002 Or iCblo Equ 110 Or iCblo Equ 104 Or iCblo Equ 105 Or iCblo Equ 106 Or iCblo Equ 107 Or iCblo Equ 108 Or iCblo Equ 113 Or iCblo Equ 114 Or iCblo Equ 120 Or iCblo Equ 999)

                    {

                         ioErroneos = ioErroneos + 1 ;

                         /*                        */

                         GetAsuntoMail( cAsunto, ccResp);

                         SaveBodyNEWERAC(cCadena, ccResp, cAsunto) ;

                         SendMailNEWERAC(cAsunto, cDreamTeam) ;

                    }

                    break;

             case IS_NSA:

                    memset(cJclNSA, '\0', sizeof(cJclNSA));

                    strncpy(cJclNSA,"proyam86 ",7) ;

                    /*--------------------------------------------*\

                     *       PONE DELIMTADOR DE DOBLES COMILLAS   *

                    \*--------------------------------------------*/

                    strcat( cJclNSA, "\"") ;

                    strcat( cJclNSA, cCadena) ;

                    /* strncat( cJclNSA, "\"", 157 ) ; */

                    strncat( cJclNSA, "\"", 213 ) ;

                    /*--------------------------------------------*\

                     *       EJECUTA EL JCL SELECCIONADO          *

                    \*--------------------------------------------*/

                    nRetVal = system( cJclNSA ) ;

                    memset( ccResp, '\0', sizeof(ccResp));

                    /* printf("Respuesta.....: %s", ccResp );  */

                    GetRespuestaNSA(ccResp, cNSARta);

                    if (send(ClientSocket, ccResp, strlen(ccResp), 0) == FAILURE)

                    {

                         close(ClientSocket) ;

                         ClientSocket = 0 ;

                         nRetVal = system( "proyam86 ERROR" ) ;

                    }

                    iConNSA=iConNSA+1;

                    /*

                     | Se cambia el grabado del log

                     | anulado GrabaLogs(cNSALog, cCadena, ccResp) ;

                     */

                    GrabaLogs(cNSALog, ccRegLog, ccResp) ;

                    iCblo=0;

                    /* printf("Respuesta.....: %s", ccResp );   */

                    iCblo=GetCodigoRespuesta(ccResp);

                    /*  printf("Respuesta.....: %s", ccResp );  */

                    /* printf("Respuesta..int...: %i", iCblo ); */

                    if(iCblo Equ 002 Or iCblo Equ 110 Or iCblo Equ 104 Or iCblo Equ 105 Or iCblo Equ 106 Or iCblo Equ 107 Or iCblo Equ 108 Or iCblo Equ 113 Or iCblo Equ 114 Or iCblo Equ 120 Or iCblo Equ 999)

                    {

                         ioErroneos = ioErroneos + 1 ;

                         /*                        */

                         GetAsuntoMail( cAsunto, ccResp);

                         SaveBodyNSA(cCadena, ccResp, cAsunto) ;

                         /*---------------------------------------*

                          * SendMailNSA(cAsunto, cDreamTeam) ;

                          *---------------------------------------*/

                         SendMailNSA(cAsunto, cCapitMarket) ;

                    }

                    break;

             case IS_MIRESIN:

                    memset(cJclMIRESIN, '\0', sizeof(cJclMIRESIN));

                    strncpy(cJclMIRESIN,"proyam88 ",7) ;

                    /*--------------------------------------------*\

                     *       PONE DELIMTADOR DE DOBLES COMILLAS   *

                    \*--------------------------------------------*/

                    strcat( cJclMIRESIN, "\"") ;

                    strcat( cJclMIRESIN, cCadena) ;

                    /* strncat( cJclMIRESIN, "\"", 157 ) ;*/

                    strncat( cJclMIRESIN, "\"", 213 ) ;

                    /* printf("Shell: %s \r\n", cJclMIRESIN) ; */

                    /*--------------------------------------------*\

                     *       EJECUTA EL JCL SELECCIONADO          *

                    \*--------------------------------------------*/

                    nRetVal = system( cJclMIRESIN ) ;

                    memset( ccResp, '\0', sizeof(ccResp));

                    GetRespuestaMIRESIN(ccResp, cMIRESINRta);

                    if (send(ClientSocket, ccResp, strlen(ccResp), 0) == FAILURE)

                    {

                         close(ClientSocket) ;

                         ClientSocket = 0 ;

                         nRetVal = system( "proyam88 ERROR" ) ;

                    }

                    iConMIRESIN=iConMIRESIN+1;

                    /*

                     | Se cambia el grabado del log

                     | anulado GrabaLogs(cMIRESINLog, cCadena, ccResp) ;

                     */

                    GrabaLogs(cMIRESINLog, ccRegLog, ccResp) ;

                    iCblo=0;

                    iCblo=GetCodigoRespuesta(ccResp);

                    if(iCblo Equ 002 Or iCblo Equ 110 Or iCblo Equ 104 Or iCblo Equ 105 Or iCblo Equ 106 Or iCblo Equ 107 Or iCblo Equ 108 Or iCblo Equ 113 Or iCblo Equ 114 Or iCblo Equ 120 Or iCblo Equ 999)

                    {

                         ioErroneos = ioErroneos + 1 ;

                         /*                        */

                         GetAsuntoMail( cAsunto, ccResp);

                         SaveBodyMIRESIN(cCadena, ccResp, cAsunto) ;

                         /*---------------------------------------*

                          * SendMailMIRESIN(cAsunto, cDreamTeam) ;

                          *---------------------------------------*/

                         SendMailMIRESIN(cAsunto, cCapitMarket) ;

                    }

                    break;

             case IS_CERRAR:

                    EstoyActivo = TENGO_Q_SALIR;

                    break;

             default:

                    printf("resultado en nSysProcd: %i \r\n", nSysProcd);

                    printf("Procedencia ERRONEA \n");

             }

         }

         /*----------------------------------------------------*\

          *        INICIALIZA VARIABLE PUNTERO AL CLIENT-SOCKET*

         \*----------------------------------------------------*/

         close(ClientSocket) ;

         ClientSocket = 0 ;

     }

/*------------ Recibe funtion ---------------------*/

int Recibe(SOCKET Socket, char * cCadena, int nBuffLen)

{

     int  nBytesRx  = 0,

          nLen      = 0,

          nBlocklen = nBuffLen;

     char *p = cCadena;

     while( true )

     {

         if ((nBytesRx = recv(Socket, p, nBlocklen - nLen, 0)) == FAILURE)

             return FAILURE;

         else if ( 0 == nBytesRx )

             break;

         if( nBlocklen - nLen == 0)

             break;

         if( strchr(p, 0x03) )

             break;

         if( strchr(p, 0x0d) )

             break;

         if( strchr(p, 0x0a) )

             break;

         if( strchr(p, 0x0D) )

             break;

         if( strchr(p, 0x0A) )

             break;

         nLen += nBytesRx;

         p += nBytesRx;

     }

     nLen = nBlocklen;

     return nLen;

}

int Presentacion()

{

      char cA2_Type_Env[LMAX_RESP]={0x00} ;

      char cA2_LibEnv[LMAX_RESP]={0x00} ;

      char cA2_Base[LMAX_RESP]={0x00} ;

      char cA2_OraVer[LMAX_RESP]={0x00} ;

      char cA2_NivPatch[LMAX_RESP]={0x00} ;

      char cA2_Niv_Info[LMAX_RESP]={0x00} ;

      printf("***************************************************************************\r\n");

      printf("AR GALICIA \t\t\t Buenos Aires\n") ;

      printf("OSERVER    \t\t\t Desarrollo\n") ;

      printf("***************************************************************************\r\n");

      memcpy(cA2_Type_Env, getenv("GA2_TYPE_ENV"), LMAX_RESP );

      memcpy(cA2_LibEnv  , getenv("GA2_LIBENV"), LMAX_RESP );

      memcpy(cA2_Base    , getenv("GA2_BASE"), LMAX_RESP );

      memcpy(cA2_OraVer  , getenv("GA2_ORAVER"), LMAX_RESP );

      memcpy(cA2_NivPatch, getenv("GA2_NIVPATCH"), LMAX_RESP );

      memcpy(cA2_Niv_Info, getenv("GA2_NIV_INFO"), LMAX_RESP );

      printf("Tipo Ambiente      \t %s \n", cA2_Type_Env ) ;

      printf("Ambiente           \t %s \n", cA2_LibEnv   ) ;

      printf("Nombre de la Base  \t %s \n", cA2_Base     ) ;

      printf("Version Oracle     \t %s \n", cA2_OraVer   ) ;

      printf("Nivel de Gestab    \t %s \n", cA2_NivPatch ) ;

      printf("Nivel de DIN       \t %s \n", cA2_Niv_Info ) ;

      return 0;

}

/*--------------------------------------------------------------------*\

 | SELECCION DEL SHELL A EJECUTAR DE ACUERDO A PROCEDENCIA DEL        |

 | MENSAJE QUE PUEDE SER: "Loganet", "NEWERAC ", "NSA    "             |

\*--------------------------------------------------------------------*/

int GetProcedencia( char * cMensaje )

{

      char cProcen[8] = "" ;

      int iComp1      = 0 ;

      int iComp2      = 0 ;

      int iComp3      = 0 ;

      int iComp4      = 0 ;

      int iComp5      = 0 ;

      char *pMensaje  = cMensaje ;

      int nResul      = -1 ;

      strncpy(cProcen, &pMensaje[51], 7) ;

      iComp1  = strncmp(cProcen,"Loganet",7) ;

      iComp2  = strncmp(cProcen,"NEWERAC ",7) ;

      iComp3  = strncmp(cProcen,"NSA    ",7) ;

      iComp4  = strncmp(cProcen,"TSN    ",7) ;

      iComp5  = strncmp(cProcen,"CERRAR ",7) ;

      if (iComp1!=0 && iComp2!=0 && iComp3!=0 && iComp4!=0 && iComp5!=0)

          nResul = -1 ;

      if (iComp1==0)

          nResul = 1 ;

      if (iComp2==0)

          nResul = 2 ;

      if (iComp3==0)

          nResul = 3 ;

      if (iComp4==0)

          nResul = 4 ;

      if (iComp5==0)

          nResul = 5 ;

      return nResul ;

}

/*-------------------------------------------------------------*\

 | Nombre......: GetNameLoganetLog()                           |

 | Tipo........: void                                          |

 | Autor.......: Yuri Orlov                                 |

 | Fecha.......: 05-05-2009                                    |

 | ............:                                               |

 | Descripcion.: Genera el Nombre del Archivo LOG donde grabara|

 |               el Mensaje que llega por Socket               |

\*-------------------------------------------------------------*/

void GetNameLoganetLog(char * ccDataLog)

{

      memset(ccDataLog, '\0', sizeof(ccDataLog));

      memcpy(ccDataLog, getenv("GA2_IMP"), LMAX_RESP );

      /*  printf("ccDataLog es : %s\n ", ccDataLog );   */

      strcat(ccDataLog, "/PROYAM82.Loganet.log" );

      /*  printf("ccDataLog es : %s\n ", ccDataLog );  */

      return;

}

/*-------------------------------------------------------------*\

 | Nombre......: GetNameLoganetResp()                          |

 | Tipo........: void                                          |

 | Autor.......: Yuri Orlov                                 |

 | Fecha.......: 05-05-2009                                    |

 | ............:                                               |

 | Descripcion.: Genera el Nombre del Archivo donde Leera la   |

 |               PRESPUESTA del Programa Cobol que Ejecuta el  |

 |               Mensaje para Loganet                          |

\*-------------------------------------------------------------*/

void GetNameLoganetResp(char * ccDataResp)

{

      memset(ccDataResp, '\0', sizeof(ccDataResp));

      memcpy(ccDataResp, getenv("GA2_IMP"), LMAX_RESP );

      strcat(ccDataResp, "/PROYAM82.XM001.sysout" );

      return;

}

/*-------------------------------------------------------------*\

 | Nombre......: GetNameNEWERACLog                              |

 | Tipo........: void                                          |