Context Navigation

ogAdmLib.c @ ebc31ef5

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

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

Context Navigation

source: admin/Sources/Includes/ogAdmLib.c @ ebc31ef5

Download in other formats: