Context Navigation

ogAdmLib.c @ 240a4dc

Visit:

918-git-images-111dconfigure-oglivegit-imageslgromero-new-oglivemainmaint-cronmount-efivarfsmultivmmultivm-ogboot-installerogClonningEngineogboot-installer-jenkinsoglive-ipv6test-python-scriptsticket-301ticket-50ticket-50-oldticket-577ticket-585ticket-611ticket-612ticket-693ticket-700ubu24tplunification2use-local-agent-oglivevarios-instalacion

Last change on this file since 240a4dc was 39f06eb, checked in by OpenGnSys Support Team <soporte-og@…>, 6 years ago

#899 Remove unused code in ogAdmLib: remove tomaPuerto()

tomaPuerto() is not used, remove it.

Property mode set to 100644

File size: 33.8 KB

Line
1	// **************************************************************************************************************************************************
2	// Libreria: ogAdmLib
3	// Autor: José Manuel Alonso (E.T.S.I.I.) Universidad de Sevilla
4	// Fecha Creación: Marzo-2010
5	// Fecha Última modificación: Marzo-2010
6	// Nombre del fichero: ogAdmLib.c
7	// Descripción: Este fichero implementa una libreria de funciones para uso común de los servicios
8	// **************************************************************************************************************************************************
9	// ________________________________________________________________________________________________________
10	// Función: tomaHora
11	//
12	// Descripción:
13	// Devuelve la hora del sistema
14	// Parametros:
15	// Ninguno
16	// ________________________________________________________________________________________________________
17	struct tm * tomaHora()
18	{
19	time_t rawtime;
20	time ( &rawtime );
21	return(localtime(&rawtime));
22	}
23	// ________________________________________________________________________________________________________
24	// Función: registraLog
25	//
26	// Descripción:
27	// Registra los eventos en un fichero log ya sean errores o información
28	// Parametros:
29	// - fileLog : Ruta completa del archivo de log
30	// - msg : Descripción del error
31	// - swe: Switch que indica si se debe recuperar además el literal de error del propio sistema operativo
32	// ________________________________________________________________________________________________________
33	void registraLog(const char* filelog,const char *msg,int swe)
34	{
35	FILE *flog;
36	struct tm * t;
37
38	t = tomaHora();
39	flog=fopen(filelog,"at");
40	if(swe)
41	fprintf (flog,"%02d/%02d/%d %02d:%02d %s: %s\n",t->tm_mday,t->tm_mon+1,t->tm_year+1900,t->tm_hour,t->tm_min,msg,strerror(errno));
42	else
43	fprintf (flog,"%02d/%02d/%d %02d:%02d %s\n",t->tm_mday,t->tm_mon+1,t->tm_year+1900,t->tm_hour,t->tm_min,msg);
44	fclose(flog);
45	}
46	// ________________________________________________________________________________________________________
47	// Función: errorLog
48	//
49	// Descripción:
50	// Registra los sucesos de errores preestablecidos en el fichero de log
51	// Parametros:
52	// - coderr : Código del mensaje de error
53	// - swe: Switch que indica si se debe recuperar además el literal de error del propio sistema operativo
54	// ________________________________________________________________________________________________________
55	void errorLog(const char *modulo, int coderr, int swe) {
56	char msglog[LONSUC];
57
58	sprintf(msglog, "*** Error: %s. Módulo %s", tbErrores[coderr], modulo);
59	registraLog(szPathFileLog, msglog, swe);
60	}
61	// ________________________________________________________________________________________________________
62	// Función: errorInfo
63	//
64	// Descripción:
65	// Registra los sucesos de errores dinámicos en el fichero de log
66	// Parametros:
67	// - msgerr : Descripción del error
68	// - swe: Switch que indica si se debe recuperar además el literal de error del propio sistema operativo
69	// ________________________________________________________________________________________________________
70	void errorInfo(const char modulo, char msgerr) {
71	char msglog[LONSUC];
72
73	sprintf(msglog, "*** Error: %s. Módulo %s", msgerr, modulo);
74	registraLog(szPathFileLog, msglog, FALSE);
75	}
76	// ________________________________________________________________________________________________________
77	// Función: infoLog
78	//
79	// Descripción:
80	// Registra los sucesos de información en el fichero de log
81	// Parametros:
82	// - coderr : Código del mensaje de información
83	// ________________________________________________________________________________________________________
84	void infoLog(int codinf) {
85	char msglog[LONSUC];
86
87	sprintf(msglog, "*** Info: %s", tbMensajes[codinf]);
88	registraLog(szPathFileLog, msglog, FALSE);
89	}
90	// ________________________________________________________________________________________________________
91	// Función: infoDebug
92	//
93	// Descripción:
94	// Registra los mensajes de debugs en el fichero de log
95	// Parametros:
96	// - msgdeb : Descripción del mensaje de información
97	// ________________________________________________________________________________________________________
98	void infoDebug(char* msgdeb) {
99	char msglog[LONSUC+15]; // Cadena de registro (reserva caracteres para el prefijo).
100
101	sprintf(msglog, "*** Debug: %d-%s", ndebug, msgdeb);
102	registraLog(szPathFileLog, msglog, FALSE);
103	}
104	//______________________________________________________________________________________________________
105	// Función: ValidacionParametros
106	//
107	// Descripción:
108	// Valida que los parametros de ejecución del programa sean correctos
109	// Parámetros:
110	// - argc: Número de argumentos
111	// - argv: Puntero a cada argumento
112	// - eje: Tipo de ejecutable (1=Servicio,2=Repositorio o 3=Cliente)
113	// Devuelve:
114	// - TRUE si los argumentos pasados son correctos
115	// - FALSE en caso contrario
116	// Especificaciones:
117	// La sintaxis de los argumentos es la siguiente
118	// -f Archivo de configuración del servicio
119	// -l Archivo de logs
120	// -d Nivel de debuger (mensages que se escribirán en el archivo de logs)
121	// Devuelve:
122	// TRUE: Si el proceso es correcto
123	// FALSE: En caso de ocurrir algún error
124	//______________________________________________________________________________________________________
125	BOOLEAN validacionParametros(int argc, char*argv[],int eje) {
126	int i;
127	char modulo[] = "validacionParametros()";
128
129	switch(eje){
130	case 1: // Administrador
131	strcpy(szPathFileCfg, "ogAdmServer.cfg"); // Valores por defecto de archivos
132	strcpy(szPathFileLog, "ogAdmServer.log"); // de configuración y de logs
133	break;
134	case 2: // Repositorio
135	strcpy(szPathFileCfg, "ogAdmRepo.cfg"); // Valores por defecto de archivos
136	strcpy(szPathFileLog, "ogAdmRepo.log"); // de configuración y de logs
137	break;
138	case 3: // Cliente OpenGnsys
139	strcpy(szPathFileCfg, "ogAdmClient.cfg"); // Valores por defecto de archivos
140	strcpy(szPathFileLog, "ogAdmClient.log"); // de configuración y de logs
141	break;
142	case 4: // Servicios DHCP,BOOTP Y TFTP
143	strcpy(szPathFileCfg, "ogAdmBoot.cfg"); // Valores por defecto de archivos
144	strcpy(szPathFileLog, "ogAdmBoot.log"); // de configuración y de logs
145	break;
146	case 5: // Agente
147	strcpy(szPathFileCfg, "ogAdmAgent.cfg"); // Valores por defecto de archivos
148	strcpy(szPathFileLog, "ogAdmAgent.log"); // de configuración y de logs
149	break;
150	case 6: // Agente
151	strcpy(szPathFileCfg, "ogAdmWinClient.cfg"); // Valores por defecto de archivos
152	strcpy(szPathFileLog, "ogAdmWinClient.log"); // de configuración y de logs
153	break;
154	case 7: // Agente
155	strcpy(szPathFileCfg, "ogAdmnxClient.cfg"); // Valores por defecto de archivos
156	strcpy(szPathFileLog, "ogAdmLnxClient.log"); // de configuración y de logs
157	break;
158	}
159
160	ndebug = 1; // Nivel de debuger por defecto
161
162	for (i = 1; (i + 1) < argc; i += 2) {
163	if (argv[i][0] == '-') {
164	switch (tolower(argv[i][1])) {
165	case 'f':
166	if (argv[i + 1] != NULL)
167	strcpy(szPathFileCfg, argv[i + 1]);
168	else {
169	errorLog(modulo, 10, FALSE);
170	return (FALSE);
171	}
172	break;
173	case 'l':
174	if (argv[i + 1] != NULL)
175	strcpy(szPathFileLog, argv[i + 1]);
176	else {
177	errorLog(modulo, 11, FALSE);
178	return (FALSE);
179	}
180	break;
181	case 'd':
182	if (argv[i + 1] != NULL) {
183	ndebug = atoi(argv[i + 1]);
184	if (ndebug < 1)
185	ndebug = 1; // Por defecto el nivel de debug es 1
186	} else
187	ndebug = 1; // Por defecto el nivel de debug es 1
188	break;
189	default:
190	errorLog(modulo, 12, FALSE);
191	exit(EXIT_FAILURE);
192	break;
193	}
194	}
195	}
196	return (TRUE);
197	}
198	//______________________________________________________________________________________________________
199	// Función: reservaMemoria
200	//
201	// Descripción:
202	// Reserva memoria para una variable
203	// Parámetros:
204	// - lon: Longitud en bytes de la reserva
205	// Devuelve:
206	// Un puntero a la zona de memoria reservada que ha sido previamente rellena con zeros o nulos
207	//______________________________________________________________________________________________________
208	char* reservaMemoria(int lon)
209	{
210	char *mem;
211
212	mem=(char*)malloc(lon);
213	if(mem!=NULL)
214	memset(mem,0,lon);
215	return(mem);
216	}
217	//______________________________________________________________________________________________________
218	// Función: ampliaMemoria
219	//
220	// Descripción:
221	// Amplia memoria para una variable
222	// Parámetros:
223	// - ptr: Puntero al buffer de memoria que se quiere ampliar
224	// - lon: Longitud en bytes de la amplicación
225	// Devuelve:
226	// Un puntero a la zona de memoria reservada que ha sido previamente rellena con zeros o nulos
227	//______________________________________________________________________________________________________
228	char* ampliaMemoria(char* ptr,int lon)
229	{
230	char *mem;
231
232	mem=(char)realloc(ptr,lonsizeof(char*));
233	if(mem!=NULL)
234	return(mem);
235	return(NULL);
236	}
237	//______________________________________________________________________________________________________
238	// Función: liberaMemoria
239	//
240	// Descripción:
241	// Libera memoria para una variable
242	// Parámetros:
243	// - ptr: Puntero al buffer de memoria que se quiere liberar
244	// Devuelve:
245	// Nada
246	//______________________________________________________________________________________________________
247	void liberaMemoria(void* ptr)
248	{
249	if(ptr){
250	free (ptr);
251	}
252	}
253	// ________________________________________________________________________________________________________
254	// Función: splitCadena
255	//
256	// Descripción:
257	// Trocea una cadena según un carácter delimitador
258	// Parámetros:
259	// - trozos: Array de punteros a cadenas
260	// - cadena: Cadena a trocear
261	// - chd: Carácter delimitador
262	// Devuelve:
263	// Número de trozos en que se divide la cadena
264	// ________________________________________________________________________________________________________
265	int splitCadena(char *trozos,char cadena, char chd)
266	{
267	int w=0;
268	if(cadena==NULL) return(w);
269
270	trozos[w++]=cadena;
271	while(*cadena!='\0'){
272	if(*cadena==chd){
273	*cadena='\0';
274	if(*(cadena+1)!='\0')
275	trozos[w++]=cadena+1;
276	}
277	cadena++;
278	}
279	return(w); // Devuelve el número de trozos
280	}
281	// ________________________________________________________________________________________________________
282	// Función: sustituir
283	//
284	// Descripción:
285	// Sustituye las apariciones de un caracter por otro en una cadena
286	// Parámetros:
287	// - cadena: Cadena a convertir
288	// - cho: Caracter a sustituir
289	// - chs: Caracter sustituto
290	// ________________________________________________________________________________________________________
291	void sustituir(char *cadena,char cho,char chs)
292	{
293	int x=0;
294
295	while(cadena[x]!=0) {
296	if (cadena[x]==cho)
297	cadena[x]=chs;
298	x++;
299	}
300	}
301	// ________________________________________________________________________________________________________
302	// Función: escaparCadena
303	//
304	// Descripción:
305	// Sustituye las apariciones de un caracter comila simple ' por \'
306	// Parámetros:
307	// - cadena: Cadena a escapar
308	// Devuelve:
309	// La cadena con las comillas simples sustituidas por \'
310	// ________________________________________________________________________________________________________
311	char* escaparCadena(char *cadena)
312	{
313	int b,c;
314	char *buffer;
315
316	buffer = (char) reservaMemoria(strlen(cadena)2); // Toma memoria para el buffer de conversión
317	if (buffer == NULL) { // No hay memoria suficiente para el buffer
318	return (FALSE);
319	}
320
321	c=b=0;
322	while(cadena[c]!=0) {
323	if (cadena[c]=='\''){
324	buffer[b++]='\\';
325	buffer[b++]='\'';
326	}
327	else{
328	buffer[b++]=cadena[c];
329	}
330	c++;
331	}
332	return(buffer);
333	}
334	// ________________________________________________________________________________________________________
335	// Función: StrToUpper
336	//
337	// Descripción:
338	// Convierta una cadena en mayúsculas
339	// Parámetros:
340	// - cadena: Cadena a convertir
341	// ________________________________________________________________________________________________________
342	char* StrToUpper(char *cadena)
343	{
344	int x=0;
345
346	while(cadena[x]!=0) {
347	if (cadena[x] >= 'a' && cadena[x] <= 'z') {
348	cadena[x] -= 32;
349	}
350	x++;
351	}
352	return(cadena);
353	}
354	// ________________________________________________________________________________________________________
355	// Función: StrToUpper
356	//
357	// Descripción:
358	// Convierta una cadena en mayúsculas
359	// Parámetros:
360	// - cadena: Cadena a convertir
361	// ________________________________________________________________________________________________________
362	char* StrToLower(char *cadena)
363	{
364	int x=0;
365
366	while(cadena[x]!=0) {
367	if (cadena[x] >= 'A' && cadena[x] <= 'Z') {
368	cadena[x] += 32;
369	}
370	x++;
371	}
372	return(cadena);
373	}
374	// ________________________________________________________________________________________________________
375	// Función: INTROaFINCAD
376	//
377	// Descripción:
378	// Cambia caracteres INTROS por fin de cadena ('\0') en una trama
379	// Parametros:
380	// - parametros: Puntero a los parametros de la trama
381	// - lon: Longitud de la cadena de parametros
382	// ________________________________________________________________________________________________________
383	void INTROaFINCAD(TRAMA* ptrTrama)
384	{
385	char i,a,*b;
386
387	a=ptrTrama->parametros;
388	b=a+ptrTrama->lonprm;
389	for(i=a;i<b;i++){ // Cambia los NULOS por INTROS
390	if(i=='\r') i='\0';
391	}
392	}
393	// ________________________________________________________________________________________________________
394	// Función: FINCADaINTRO
395	//
396	// Descripción:
397	// Cambia caracteres fin de cadena ('\0') por INTROS en una trama
398	// Parametros:
399	// - parametros: Puntero a los parametros de la trama
400	// - lon: Longitud de la cadena de parametros
401	// ________________________________________________________________________________________________________
402	void FINCADaINTRO(TRAMA* ptrTrama)
403	{
404	char i,a,*b;
405
406	a=ptrTrama->parametros;
407	b=a+ptrTrama->lonprm;
408	for(i=a;i<b;i++){ // Cambia los NULOS por INTROS
409	if(i=='\0') i='\r';
410	}
411	}
412	// ________________________________________________________________________________________________________
413	// Función: cuentaIPES
414	//
415	// Descripción:
416	// Cuenta los caracteres "." de las IPES dentro del parámetros iph de una trama
417	// con lo cual dividiendo por 3 se puede saber la cantdad de direcciones IPES en la cadena
418	// Parametros:
419	// - ipes: Cadena con las IPES separadas por ";"
420	// ________________________________________________________________________________________________________
421	int cuentaIPES(char* ipes)
422	{
423	int i,a,b,c=0;
424
425	a=0;
426	b=strlen(ipes);
427	for(i=a;i<b;i++){ // Cambia los NULOS por INTROS
428	if(ipes[i]=='.') c++;
429	}
430	return(c/3);
431	}
432	// ________________________________________________________________________________________________________
433	// Función: tomaParametro
434	//
435	// Descripción:
436	// Devuelve el valor de un parametro incluido en una cadena con formatos: "nombre=valor"
437	// Parámetros:
438	// - nombre: Nombre del parámetro a recuperar
439	// - paramestros: Cadena que contiene todos los parámetros
440	// ________________________________________________________________________________________________________
441	char* tomaParametro(const char* nombre,TRAMA* ptrTrama)
442	{
443	char a,b,*pos;
444
445	a=ptrTrama->parametros;
446	b=a+ptrTrama->lonprm;
447	for(pos=a;pos<b;pos++){ // Busca valor del parámetro
448	if(pos[0]==nombre[0]){
449	if(pos[1]==nombre[1]){
450	if(pos[2]==nombre[2]){
451	if(pos[3]=='='){
452	pos+=4;
453	return(pos);
454	}
455	}
456	}
457	}
458	}
459	return(NULL);
460	}
461	//______________________________________________________________________________________________________
462	// Función: copiaParametro
463	//
464	// Descripción:
465	// Devuelve una copia del valor de un parámetro
466	// Parámetros:
467	// - ptrTrama: contenido del mensaje
468	// - parametro: Nombre del parámetro
469	// - lon: Nombre del parámetro
470	// Devuelve:
471	// Un puntero a la cadena que contiene el valor del parámetro
472	// ________________________________________________________________________________________________________
473	char* copiaParametro(const charnombre,TRAMA ptrTrama)
474	{
475	char prm,buffer;
476	char modulo[] = "copiaParametro()";
477
478
479	prm=tomaParametro(nombre,ptrTrama); // Toma identificador de acción
480	if(!prm)
481	return(NULL);
482	buffer = (char*) reservaMemoria(strlen(prm)+1); // Toma memoria para el buffer de lectura.
483	if (buffer == NULL) { // No hay memoria suficiente para el buffer
484	errorLog(modulo, 3, FALSE);
485	return (FALSE);
486	}
487	strcpy(buffer,prm);
488	return(buffer);
489	}
490	// ________________________________________________________________________________________________________
491	// Función: igualIP
492	//
493	// Descripción:
494	// Comprueba si una cadena con una dirección IP está incluida en otra que contienen varias direcciones ipes
495	// separadas por punto y coma
496	// Parámetros:
497	// - cadenaiph: Cadena de direcciones IPES
498	// - ipcliente: Cadena de la IP a buscar
499	// Devuelve:
500	// TRUE: Si el proceso es correcto
501	// FALSE: En caso de ocurrir algún error
502	// ________________________________________________________________________________________________________
503	BOOLEAN contieneIP(char cadenaiph,char ipcliente)
504	{
505	char posa,posb;
506	int lon;
507
508	posa=strstr(cadenaiph,ipcliente);
509	if(posa==NULL) return(FALSE); // No existe la IP en la cadena
510	posb=posa; // Iguala direcciones
511	while(TRUE){
512	posb++;
513	if(*posb==';') break;
514	if(*posb=='\0') break;
515	if(*posb=='\r') break;
516	}
517	lon=strlen(ipcliente);
518	if((posb-posa)==lon) return(TRUE); // IP encontrada
519	return(FALSE);
520	}
521	// ________________________________________________________________________________________________________
522	// Función: rTrim
523	//
524	// Descripción:
525	// Elimina caracteres de espacios y de asci menor al espacio al final de la cadena
526	// Parámetros:
527	// - cadena: Cadena a procesar
528	// ________________________________________________________________________________________________________
529	char* rTrim(char *cadena)
530	{
531	int i,lon;
532
533	lon=strlen(cadena);
534	for (i=lon-1;i>=0;i--){
535	if(cadena[i]<32)
536	cadena[i]='\0';
537	else
538	return(cadena);
539	}
540	return(cadena);
541	}
542	// ________________________________________________________________________________________________________
543	// Función: mandaTrama
544	//
545	// Descripción:
546	// Envía una trama por la red
547	// Parametros:
548	// - sock : El socket del host al que se dirige la trama
549	// - trama: El contenido de la trama
550	// - lon: Longitud de la parte de parametros de la trama que se va a mandar
551	// Devuelve:
552	// TRUE: Si el proceso es correcto
553	// FALSE: En caso de ocurrir algún error
554	// ________________________________________________________________________________________________________
555	BOOLEAN mandaTrama(SOCKET sock, TRAMA ptrTrama)
556	{
557	int lonprm;
558	char *buffer,hlonprm[LONHEXPRM+1];
559	BOOLEAN res;
560
561	lonprm=strlen(ptrTrama->parametros);
562	sprintf(hlonprm,"%05X",LONGITUD_CABECERATRAMA+LONHEXPRM+lonprm); // Convierte en hexadecimal la longitud
563
564	buffer=reservaMemoria(LONGITUD_CABECERATRAMA+LONHEXPRM+lonprm); // Longitud total de la trama
565	if(buffer==NULL)
566	return(FALSE);
567	memcpy(buffer,ptrTrama,LONGITUD_CABECERATRAMA); // Copia cabecera de trama
568	memcpy(&buffer[LONGITUD_CABECERATRAMA],hlonprm,LONHEXPRM); // Copia longitud de la trama
569	memcpy(&buffer[LONGITUD_CABECERATRAMA+LONHEXPRM],ptrTrama->parametros,lonprm);
570	res=sendData(sock,buffer,LONGITUD_CABECERATRAMA+LONHEXPRM+lonprm);
571	liberaMemoria(buffer);
572	return (res);
573	}
574	// ________________________________________________________________________________________________________
575	// Función: sendData
576	//
577	// Descripción:
578	// Envía datos por la red a través de un socket
579	// Parametros:
580	// - sock : El socket por donde se envía
581	// - datos: El contenido a enviar
582	// - lon: Cantidad de bites a enviar
583	// Devuelve:
584	// TRUE: Si el proceso es correcto
585	// FALSE: En caso de ocurrir algún error
586	// ________________________________________________________________________________________________________
587	BOOLEAN sendData(SOCKET sock, char datos,int lon)
588	{
589	int idx,ret;
590	idx = 0;
591	while (lon > 0) {
592	ret = send(*sock,&datos[idx],lon, 0);
593	if (ret == 0) { // Conexión cerrada por parte del cliente (Graceful close)
594	break;
595	}
596	else{
597	if (ret == SOCKET_ERROR)
598	return (FALSE);
599	}
600	lon -= ret;
601	idx += ret;
602	}
603	return (TRUE);
604	}
605	// ________________________________________________________________________________________________________
606	// Función: recibeTrama
607	//
608	// Descripción:
609	// Recibe una trama por la red
610	// Parametros:
611	// - sock : El socket del cliente
612	// - trama: El buffer para recibir la trama
613	// Devuelve:
614	// Un puntero a una estrucutra TRAMA o NULL si ha habido algún error
615	// FALSE: En caso de ocurrir algún error
616	// ________________________________________________________________________________________________________
617	TRAMA* recibeTrama(SOCKET *sock)
618	{
619	int ret,lon,lSize;
620	char buffer,bufferd,bloque[LONBLK],*hlonprm;
621	TRAMA * ptrTrama;
622
623	lon=lSize=0;
624	do{
625	if(!recData(sock,bloque,LONBLK,&ret)) // Lee bloque
626	return(NULL);
627
628	if (lon==0 && lSize==0 && ret==0) // Comprueba trama válida
629	return(NULL);
630
631	if(lSize==0){ // Comprueba tipo de trama y longitud total de los parámetros
632	if (strncmp(bloque, "@JMMLCAMDJ_MCDJ",15)!=0)
633	return(NULL); // No se reconoce la trama
634	hlonprm=reservaMemoria(LONHEXPRM+1);
635	if(!hlonprm) return(NULL);
636	memcpy(hlonprm,&bloque[LONGITUD_CABECERATRAMA],LONHEXPRM);
637	lSize=strtol(hlonprm,NULL,16); // Longitud total de la trama con los parametros encriptados
638	liberaMemoria(hlonprm);
639	buffer=(char*)reservaMemoria(lSize); // Toma memoria para la trama completa
640	if(!buffer)
641	return(NULL);
642	}
643
644	if(ret>0){ // Datos recibidos
645	memcpy(&buffer[lon],bloque,ret); // Añade bloque
646	lon+=ret;
647	}
648	}while(lon<lSize);
649
650	ptrTrama=(TRAMA *)reservaMemoria(sizeof(TRAMA));
651	if (!ptrTrama) return(NULL);
652	memcpy(ptrTrama,buffer,LONGITUD_CABECERATRAMA); // Copia cabecera de trama
653	lon=lSize-(LONGITUD_CABECERATRAMA+LONHEXPRM); // Longitud de los parametros aún encriptados
654	bufferd = &buffer[LONGITUD_CABECERATRAMA+LONHEXPRM];
655	initParametros(ptrTrama,lon); // Desencripta la trama
656	memcpy(ptrTrama->parametros,bufferd,lon);
657	liberaMemoria((char*)buffer);
658	ptrTrama->lonprm=lon; // Almacena longitud de los parámetros ya desencriptados
659	return(ptrTrama);
660	}
661	// ________________________________________________________________________________________________________
662	// Función: recData
663	//
664	// Descripción:
665	// Recibe datos por la red a través de un socket
666	// Parametros:
667	// - sock : El socket por el que se reciben los datos
668	// - datos: El buffer donde se almacenan
669	// - lon: Cantidad máxima de bites a recibir
670	// - ret: Cantidad de bites recibidos (Parámetro de salida)
671	// Devuelve:
672	// TRUE: Si el proceso es correcto
673	// FALSE: En caso de ocurrir algún error
674	// ________________________________________________________________________________________________________
675	BOOLEAN recData(SOCKET sock, char buffer,int lon,int* ret)
676	{
677	*ret = 0;
678
679	while (TRUE) { // Bucle para recibir datos del cliente
680	ret = recv(sock,buffer, lon, 0);
681	if (*ret == 0) // Conexión cerrada por parte del cliente (Graceful close)
682	break;
683	else {
684	if (*ret == SOCKET_ERROR) {
685	return (FALSE);
686	} else
687	// Datos recibidos
688	break;
689	}
690	}
691	return(TRUE);
692	}
693	//______________________________________________________________________________________________________
694	// Función: enviaFlag
695	//
696	// Descripción:
697	// Envia una señal de sincronización
698	// Parámetros:
699	// - socket_c: (Salida) Socket utilizado para el envío (operativo)
700	// - ptrTrama: contenido del mensaje
701	// Devuelve:
702	// TRUE: Si el proceso es correcto
703	// FALSE: En caso de ocurrir algún error
704	// ________________________________________________________________________________________________________
705	BOOLEAN enviaFlag(SOCKET socket_c,TRAMA ptrTrama)
706	{
707	char modulo[] = "enviaFlag()";
708	if (!mandaTrama(socket_c,ptrTrama)) {
709	errorLog(modulo,26,FALSE);
710	return (FALSE);
711	}
712	return(TRUE);
713	}
714	//______________________________________________________________________________________________________
715	// Función: recibeFlag
716	//
717	// Descripción:
718	// Recibe una señal de sincronización
719	// Parámetros:
720	// - socket_c: Socket utilizadopara la recepción (operativo)
721	// - ptrTrama: (Salida) Contenido del mensaje
722	// Devuelve:
723	// TRUE: Si el proceso es correcto
724	// FALSE: En caso de ocurrir algún error
725	// ________________________________________________________________________________________________________
726	BOOLEAN recibeFlag(SOCKET socket_c,TRAMA ptrTrama)
727	{
728	ptrTrama=recibeTrama(socket_c);
729	if(!ptrTrama){
730	return(FALSE);
731	}
732	return(TRUE);
733	}
734	//______________________________________________________________________________________________________
735	// Función: URLEncode
736	//
737	// Descripción:
738	// Codifica una cadena en UrlEncode
739	// Parámetros:
740	// - src: La cadena a decodificar
741	// Devuelve:
742	// La cadena decodificada
743	// ________________________________________________________________________________________________________
744	char* URLEncode(char *src)
745	{
746	char *dest;
747	int i,j=0,lon;
748
749	lon=strlen(src);
750	dest=(char)reservaMemoria(lon2); // Reserva buffer para la cadena
751	for(i=0;i<lon;i++){
752	if(src[i]==0x20){ // Espacio
753	dest[j++] = '%';
754	dest[j++] = '2';
755	dest[j++] = '0';
756	}
757	else
758	dest[j++] = src[i];
759	}
760	return(dest);
761	}
762	//______________________________________________________________________________________________________
763	// Función: URLDecode
764	//
765	// Descripción:
766	// Decodifica una cadena codificada con UrlEncode
767	// Parámetros:
768	// - src: La cadena a decodificar
769	// Devuelve:
770	// La cadena decodificada
771	// ________________________________________________________________________________________________________
772	char* URLDecode(char *src)
773	{
774	const char *p = src;
775	char code[3] = {0};
776	unsigned long ascii = 0;
777	char *end = NULL;
778	char dest,cad;
779
780	dest=(char*)reservaMemoria(strlen(src)); // Reserva buffer para la cadena
781	cad=dest;
782	while(*p){
783	if(*p == '%'){
784	memcpy(code, ++p, 2);
785	ascii = strtoul(code, &end, 16);
786	*dest++ = (char)ascii;
787	p += 2;
788	}
789	else
790	dest++ = p++;
791	}
792	return(cad);
793	}
794	// ________________________________________________________________________________________________________
795	// Función: leeArchivo
796	//
797	// Descripción:
798	// Lee un archivo
799	// Parámetros:
800	// fil: Nombre completo del archivo
801	// Devuelve:
802	// Un puntero al buffer con el contenido leido
803
804	//______________________________________________________________________________________________________
805	char * leeArchivo(char *fil)
806	{
807	FILE *f;
808	long lSize;
809	char* buffer;
810
811	f=fopen(fil,"rb");
812	if (!f)
813	return(NULL);
814	fseek (f,0,SEEK_END); // Obtiene tamaño del fichero.
815	lSize = ftell (f);
816	rewind (f);
817	buffer = (char*) reservaMemoria(lSize+1); // Toma memoria para el buffer de lectura.
818	if (!buffer) // No hay memoria suficiente para el buffer
819	return (NULL);
820	lSize=fread (buffer,1,lSize,f); // Lee contenido del fichero
821	fclose(f);
822	return (buffer);
823	}
824	// ________________________________________________________________________________________________________
825	// Función: leeArchivo
826	//
827	// Descripción:
828	// Calcula la longitud de un archivo
829	// Parámetros:
830	// fil: Nombre completo del archivo
831	// Devuelve:
832	// Un puntero al buffer con el contenido leido
833
834	//______________________________________________________________________________________________________
835	int lonArchivo(char *fil)
836	{
837	FILE *f;
838	long lSize;
839
840	f=fopen(fil,"rb");
841	if (!f)
842	return(0);
843	fseek (f,0,SEEK_END); // Obtiene tamaño del fichero.
844	lSize = ftell (f);
845	fclose(f);
846	return (lSize);
847	}
848	// ________________________________________________________________________________________________________
849	// Función: escribeArchivo
850	//
851	// Descripción:
852	// Escribe un archivo
853	// Parámetros:
854	// fil: Nombre completo del archivo
855	// buffer: Un puntero al buffer con el contenido a escribir
856	// Devuelve:
857	//______________________________________________________________________________________________________
858	BOOLEAN escribeArchivo(char fil,charbuffer)
859	{
860	FILE *f;
861	long lSize;
862
863	f=fopen(fil,"wb");
864	if (!f){
865	return(FALSE);
866	}
867	lSize=strlen(buffer);
868	fwrite(buffer,1,lSize,f); // Escribe el contenido en el fichero
869	fclose(f);
870	return (TRUE);
871	}
872	// ________________________________________________________________________________________________________
873	// Función: sendArchivo
874	//
875	// Descripción:
876	// Envía un archivo por la red
877	// Parámetros:
878	// sock: Socket para el envío
879	// fil: Nombre local completo del archivo
880	// Devuelve:
881	// TRUE: Si el proceso es correcto
882	// FALSE: En caso de ocurrir algún error
883	//______________________________________________________________________________________________________
884	BOOLEAN sendArchivo(SOCKET sock,char fil)
885	{
886	long lSize;
887	FILE *f;
888	char buffer[LONBLK];
889
890	f = fopen(fil,"rb");
891	if(!f) // El fichero no existe
892	return(FALSE);
893
894	while(!feof(f)){
895	lSize=fread (buffer,1,LONBLK,f); // Lee el contenido del fichero
896	if(!sendData(sock,buffer,lSize))
897	return (FALSE);
898	}
899	fclose(f);
900	return(TRUE);
901	}
902	// ________________________________________________________________________________________________________
903	// Función: recArchivo
904	//
905	// Descripción:
906	// Recibe un archivo por la red
907	// Parámetros:
908	// sock: Socket para la recepción
909	// fil: Nombre local completo del archivo que se creará
910	// Devuelve:
911	// TRUE: Si el proceso es correcto
912	// FALSE: En caso de ocurrir algún error
913	//______________________________________________________________________________________________________
914	BOOLEAN recArchivo(SOCKET sock,char fil)
915	{
916	int lon;
917	FILE *f;
918	char buffer[LONBLK];
919
920	f = fopen(fil,"wb");
921	if(!f) // No se ha podido crear el archivo
922	return(FALSE);
923	do{
924	if(!recData(sock,buffer,LONBLK,&lon))
925	return(FALSE);
926	// Datos recibidos
927	if(lon>0)
928	fwrite(buffer,1,lon,f); // Lee el contenido del fichero
929	}while(lon>0); // Bucle para recibir datos del cliente
930	fclose(f);
931	return(TRUE);
932	}
933	//______________________________________________________________________________________________________
934	// Función: initParammetros
935	//
936	// Descripción:
937	// Libera memoria del buffer de los parametros de la trama y vuelve a reservar espacio
938	// Parámetros:
939	// - parametros : Puntero a la zona donde están los parametros de una trama
940	// - lon : Tamaño de la nueva reserva de espacio para los parametros
941	// Devuelve:
942	// Un puntero a la nueva zona de memoria o NULL si ha habido algún error
943	// Especificaciones:
944	// En caso de que el parámetro lon valga cero el tamaño a reservar será el estandar
945	//______________________________________________________________________________________________________
946	BOOLEAN initParametros(TRAMA* ptrTrama,int lon)
947	{
948	if(lon==0) lon=LONGITUD_PARAMETROS;
949	ptrTrama->parametros=(char*)ampliaMemoria(ptrTrama->parametros,lon);
950	if(!ptrTrama->parametros)
951	return(FALSE);
952	else
953	return(TRUE);
954	}
955	//______________________________________________________________________________________________________
956	// Función: TCPConnect
957	//
958	// Descripción:
959	// Crea un socket y lo conecta a un servidor
960	// Parámetros:
961	// - ips : La Dirección IP del servidor
962	// - port : Puerto para la comunicación
963	// Devuelve:
964	// Un socket para comunicaciones por protocolo TCP
965	//______________________________________________________________________________________________________
966	SOCKET TCPConnect(char ips,char port)
967	{
968	SOCKET s;
969	struct sockaddr_in server;
970	char modulo[] = "TCPConnect()";
971
972	s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
973	if (s == INVALID_SOCKET){
974	return (INVALID_SOCKET);
975	}
976	server.sin_family = AF_INET;
977	server.sin_port = htons((short)atoi(port));
978	server.sin_addr.s_addr = inet_addr(ips);
979
980	if (connect(s, (struct sockaddr *)&server, sizeof(server)) == INVALID_SOCKET){
981	errorLog(modulo,38,TRUE);
982	return (INVALID_SOCKET);
983	}
984
985	return(s);
986	}
987	//______________________________________________________________________________________________________
988	// Función: AbreConexion
989	//
990	// Descripción:
991	// Abre la conexión entre el cliente y el servidor de administración
992	// Parámetros:
993	// - Ninguno
994	// Devuelve:
995	// Un socket de cliente para comunicaciones
996	//______________________________________________________________________________________________________
997	SOCKET abreConexion(void)
998	{
999	int swloop=0;
1000	SOCKET s;
1001
1002	while(swloop<MAXCNX){
1003	s=TCPConnect(servidoradm,puerto);
1004	if(s!= INVALID_SOCKET){
1005	return(s);
1006	}
1007	swloop++;
1008	#ifdef __WINDOWS__
1009	Sleep(5*1000);
1010	#else
1011	sleep(5); // Espera cinco segundos antes de intentar una nueva conexión
1012	#endif
1013	}
1014	return(INVALID_SOCKET);
1015	}
1016	//______________________________________________________________________________________________________
1017	// Función: enviaMensaje
1018	//
1019	// Descripción:
1020	// Envia un mensaje al servidor de Administración
1021	// Parámetros:
1022	// - socket_c: (Salida) Socket utilizado para el envío
1023	// - ptrTrama: contenido del mensaje
1024	// - tipo: Tipo de mensaje
1025	// C=Comando, N=Respuesta a un comando, P=Peticion,R=Respuesta a una petición, I=Informacion
1026	// Devuelve:
1027	// TRUE: Si el proceso es correcto
1028	// FALSE: En caso de ocurrir algún error
1029	// ________________________________________________________________________________________________________
1030	BOOLEAN enviaMensaje(SOCKET socket_c,TRAMA ptrTrama,char tipo)
1031	{
1032	char modulo[] = "enviaMensaje()";
1033
1034	*socket_c=abreConexion();
1035	if(*socket_c==INVALID_SOCKET){
1036	errorLog(modulo,38,FALSE); // Error de conexión con el servidor
1037	return(FALSE);
1038	}
1039	ptrTrama->arroba='@'; // Cabecera de la trama
1040	strncpy(ptrTrama->identificador,"JMMLCAMDJ_MCDJ",14); // identificador de la trama
1041	ptrTrama->tipo=tipo; // Tipo de mensaje
1042
1043	if (!mandaTrama(socket_c,ptrTrama)) {
1044	errorLog(modulo,26,FALSE);
1045	return (FALSE);
1046	}
1047	return(TRUE);
1048	}
1049	//______________________________________________________________________________________________________
1050	// Función: recibeMensaje
1051	//
1052	// Descripción:
1053	// Recibe un mensaje del servidor de Administración
1054	// Parámetros:
1055	// - socket_c: Socket utilizadopara la recepción
1056	// - ptrTrama: (Salida) Contenido del mensaje
1057	// Devuelve:
1058	// TRUE: Si el proceso es correcto
1059	// FALSE: En caso de ocurrir algún error
1060	// ________________________________________________________________________________________________________
1061	TRAMA* recibeMensaje(SOCKET *socket_c)
1062	{
1063	TRAMA* ptrTrama;
1064	char modulo[] = "recibeMensaje()";
1065
1066	ptrTrama=recibeTrama(socket_c);
1067	if(!ptrTrama){
1068	errorLog(modulo,17,FALSE);
1069	return(NULL);
1070	}
1071	return(ptrTrama);
1072	}
1073
1074	// ________________________________________________________________________________________________________

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: admin/Sources/Includes/ogAdmLib.c @ 240a4dc

Download in other formats: