Context Navigation

ogAdmLib.c @ 09f40008

Visit:

918-git-images-111dconfigfileconfigure-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-instalacionwebconsole3

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

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

Context Navigation

source: admin/Sources/Includes/ogAdmLib.c @ 09f40008

Download in other formats: