Annotation of rpm2html/sql.c, revision 1.41
1.1 veillard 1: /*
2: * sql.c: front-end for MySQL database
3: */
4:
1.2 veillard 5: #include "config.h"
6:
7: #include <stdio.h>
8: #include <stdlib.h>
9: #include <sys/types.h>
10: #include <sys/stat.h>
11: #ifdef HAVE_FCNTL_H
12: #include <fcntl.h>
13: #endif
1.1 veillard 14: #include <stdio.h>
15: #include <stdlib.h>
1.2 veillard 16: #include <string.h>
1.28 daniel 17: #include <time.h>
1.2 veillard 18: #ifdef HAVE_UNISTD_H
19: #include <unistd.h>
20: #endif
21: /********
22: #include <rpm/rpmlib.h>
23: ********/
24:
1.1 veillard 25: #include <mysql/mysql.h>
1.16 veillard 26: #include <mysql/errmsg.h>
1.2 veillard 27: #include "rpm2html.h"
1.26 veillard 28: #include "rpmdata.h"
1.2 veillard 29: /********
30: #include "rpmdata.h"
31: ********/
1.1 veillard 32: #include "sql.h"
1.28 daniel 33: #include "html.h"
1.1 veillard 34:
1.39 daniel 35: /* #define SQL_DEBUG_TIMING */
1.31 veillard 36:
1.26 veillard 37: #define SQL_MAX_DISTRIBS 500
38:
1.1 veillard 39: /************************************************************************
40: * *
41: * Generic inititialisation/close of the DB *
42: * *
43: ************************************************************************/
44:
45: static MYSQL *sql = NULL;
1.16 veillard 46: static const char *myhost, *mybase, *myuser, *mypasswd;
1.1 veillard 47:
1.11 veillard 48: int init_sql(const char *host, const char *base, const char *user, const char *passwd) {
1.16 veillard 49: int attempts = 0;
50:
51: /*
52: * Close the previous connection if any
53: */
54: if (sql != NULL) {
55: close_sql();
56: if (myhost != NULL) free((char *) myhost);
57: myhost = NULL;
58: if (mybase != NULL) free((char *) mybase);
59: mybase = NULL;
60: if (myuser != NULL) free((char *) myuser);
61: myuser = NULL;
62: if (mypasswd != NULL) free((char *) mypasswd);
63: mypasswd = NULL;
64: }
65:
1.11 veillard 66: if (host == NULL)
67: host = getenv("MySQL_HOST");
68: if (host == NULL)
69: host = "localhost";
70: if (base == NULL)
71: base = getenv("MySQL_BASE");
1.1 veillard 72: if (base == NULL)
73: base = "rpmfind";
74: if (passwd == NULL)
75: passwd = getenv("MySQL_PASS");
76: if (user == NULL)
77: user = getenv("MySQL_USER");
78: if (user == NULL)
79: user = getenv("USER");
80: if (user == NULL)
81: user = getenv("USERNAME");
82: if (user == NULL)
83: user = getenv("LOGNAME");
84: sql = mysql_init(NULL);
85: if (mysql_errno(sql)) {
86: fprintf(stderr, "mysql_init failed: %s\n", mysql_error(sql));
87: return(-1);
88: }
1.16 veillard 89: for (attempts = 0; ;attempts ++) {
90: mysql_real_connect(sql, host, user, passwd, base, 0, NULL, 0);
91: if (mysql_errno(sql)) {
1.26 veillard 92: if ((attempts == 0) && (passwd == NULL)) {
93: fprintf(stderr, "No passwd defined, use MySQL_PASS env\n");
94: }
1.16 veillard 95: if (attempts >= 20) {
96: fprintf(stderr,
97: "mysql: connect as %s to %s on host %s failed: %s\n",
98: user, base, host, mysql_error(sql));
1.24 daniel 99: return(-1);
100: } else {
101: fprintf(stderr,
102: "mysql: retrying connect as %s to %s on host %s failed: %s\n",
103: user, base, host, mysql_error(sql));
1.16 veillard 104: }
105: } else {
106: break;
107: }
108: sleep(15);
1.1 veillard 109: }
1.16 veillard 110: myhost = strdup(host);
111: mybase = strdup(base);
112: myuser = strdup(user);
113: mypasswd = strdup(passwd);
1.2 veillard 114: sql_check_tables();
1.1 veillard 115: return(0);
116: }
117:
118: int close_sql(void) {
119: mysql_close(sql);
120: if (mysql_errno(sql)) {
121: fprintf(stderr, "mysql_close failed: %s\n", mysql_error(sql));
122: return(-1);
123: }
1.16 veillard 124: sql = NULL;
1.1 veillard 125: return(0);
126: }
127:
1.16 veillard 128: int restart_sql(void) {
129: int attempts = 0;
130:
131: /*
132: * Close the previous connection if any
133: */
134: if (sql != NULL) {
135: close_sql();
136: sql = NULL;
137: }
138:
139: sql = mysql_init(NULL);
140: if (mysql_errno(sql)) {
141: fprintf(stderr, "mysql_init failed: %s\n", mysql_error(sql));
142: return(-1);
143: }
144: for (attempts = 0; ;attempts ++) {
145: mysql_real_connect(sql, myhost, myuser, mypasswd, mybase, 0, NULL, 0);
146: if (mysql_errno(sql)) {
147: if (attempts >= 20) {
148: fprintf(stderr,
149: "mysql: reconnect as %s to %s on host %s failed: %s\n",
150: myuser, mybase, myhost, mysql_error(sql));
151: return(-1);
152: }
153: } else {
154: break;
155: }
156: sleep(15);
157: }
158: sql_check_tables();
159: return(0);
160: }
161:
162: /*
163: * Handle disconnects by doing a reconnect and a retry.
164: */
165: int do_sql_query(const char *query, int len) {
166: int res;
167:
168: if (sql == NULL) {
169: res = restart_sql();
170: if (res != 0)
171: return(res);
172: }
173: res = mysql_real_query(sql, query, len);
1.19 daniel 174: if ((res == CR_SERVER_GONE_ERROR) || (res == CR_SERVER_LOST)) {
1.16 veillard 175: res = restart_sql();
176: if (res != 0)
177: return(res);
178: res = mysql_real_query(sql, query, len);
179: }
180: return(res);
181: }
182:
1.1 veillard 183: /************************************************************************
184: * *
185: * Generic functions to access the tables *
186: * *
187: ************************************************************************/
188:
1.6 veillard 189: #define MAX_QUERY 8000
190: #define SMALL_QUERY 500
1.1 veillard 191:
192: int sql_update_id(const char *table, int id,
193: const char *field, const char *value) {
194: MYSQL_RES *result;
1.6 veillard 195: char query[MAX_QUERY];
1.1 veillard 196: int nb_fields = 0;
1.6 veillard 197: int left = MAX_QUERY - 1;
198: int len;
199: char *end;
1.1 veillard 200:
201: if ((table == NULL) ||
202: (field == NULL) || (value == NULL))
203: return(-1);
204:
1.6 veillard 205: len = snprintf(query, left, "UPDATE %s SET %s='", table, field);
206: if (len < 0) {
207: fprintf(stderr, "sql_update_id : %s(%d).%s overflow\n",
208: table, id, field);
209: return(-1);
210: }
211: end = &query[len];
212: left -= len;
213: len = strlen(value);
214: if (len * 2 >= left) {
215: fprintf(stderr, "sql_update_id : %s(%d).%s overflow\n",
216: table, id, field);
217: return(-1);
218: }
219: len = mysql_escape_string(end, value, len);
220: left -= len;
221: if (left <= 0) {
222: fprintf(stderr, "sql_update_id : %s(%d).%s overflow\n",
223: table, id, field);
224: return(-1);
225: }
226: end += len;
227: len = snprintf(end, left, "' WHERE ID=%d", id);
228: if (len < 0) {
229: fprintf(stderr, "sql_update_id : %s(%d).%s overflow\n",
230: table, id, field);
231: return(-1);
232: }
233: end += len;
234: query[MAX_QUERY - 1] = 0;
235:
1.16 veillard 236: if (do_sql_query(query, (unsigned int) (end - query))) {
1.1 veillard 237: printf("sql_update_id: UPDATE %s %d failed: %s\n",
238: table, id, mysql_error(sql));
239: return(-1);
240: }
241: result = mysql_store_result(sql);
242: if (result != NULL) {
243: nb_fields = mysql_num_fields(result);
244: mysql_free_result(result);
245: } else {
246: nb_fields = 1;
247: }
248: if(mysql_errno(sql)) {
249: fprintf(stderr, "sql_update_id UPDATE error: %s\n",
250: mysql_error(sql));
251: return(-1);
252: }
253: return(nb_fields);
254: }
255:
256: int sql_blind_insert(const char *table, const char *key,
257: const char *value, int id) {
258: MYSQL_RES *result;
1.6 veillard 259: char query[MAX_QUERY];
260: int left = MAX_QUERY - 1;
261: int len;
262: char *end;
1.8 veillard 263: int insert = -1;
1.1 veillard 264:
1.2 veillard 265: if ((table == NULL) ||
1.1 veillard 266: (key == NULL) || (value == NULL))
267: return(-1);
268:
269: /*
270: * Search first for the ID if it already exists
271: */
1.2 veillard 272: if (id > 0) {
1.6 veillard 273: len = snprintf(query, left, "INSERT INTO %s (ID, %s) VALUES (%d, '",
274: table, key, id);
275: if (len < 0) {
276: fprintf(stderr, "sql_blind_insert : %s(%d).%s overflow\n",
277: table, id, key);
278: return(-1);
279: }
280: end = &query[len];
281: left -= len;
282: len = strlen(value);
283: if (len * 2 >= left) {
284: fprintf(stderr, "sql_blind_insert : %s(%d).%s overflow\n",
285: table, id, key);
286: return(-1);
287: }
288: len = mysql_escape_string(end, value, len);
289: left -= len;
290: if (left <= 0) {
291: fprintf(stderr, "sql_blind_insert : %s(%d).%s overflow\n",
292: table, id, key);
293: return(-1);
294: }
295: end += len;
296: len = snprintf(end, left, "')");
297: if (len < 0) {
298: fprintf(stderr, "sql_blind_insert : %s(%d).%s overflow\n",
299: table, id, key);
300: return(-1);
301: }
302: end += len;
303: query[MAX_QUERY - 1] = 0;
304:
1.2 veillard 305: } else {
1.6 veillard 306: len = snprintf(query, left, "INSERT INTO %s (%s) VALUES ('",
307: table, key);
308: if (len < 0) {
309: fprintf(stderr, "sql_blind_insert : %s.%s overflow\n",
310: table, key);
311: return(-1);
312: }
313: end = &query[len];
314: left -= len;
315: len = strlen(value);
316: if (len * 2 >= left) {
317: fprintf(stderr, "sql_blind_insert : %s.%s overflow\n",
318: table, key);
319: return(-1);
320: }
321: len = mysql_escape_string(end, value, len);
322: left -= len;
323: if (left <= 0) {
324: fprintf(stderr, "sql_blind_insert : %s.%s overflow\n",
325: table, key);
326: return(-1);
327: }
328: end += len;
329: len = snprintf(end, left, "')");
330: if (len < 0) {
331: fprintf(stderr, "sql_blind_insert : %s.%s overflow\n",
332: table, key);
333: return(-1);
334: }
335: end += len;
336: query[MAX_QUERY - 1] = 0;
337:
1.2 veillard 338: }
1.6 veillard 339: query[MAX_QUERY - 1] = 0;
1.16 veillard 340: if (do_sql_query(query, (unsigned int) (end - query))) {
1.6 veillard 341: #ifdef SQL_DEBUG
342: fprintf(stderr, "sql_blind_insert Error: %s\n", mysql_error(sql));
343: #endif
1.1 veillard 344: return(-1);
345: }
346: result = mysql_store_result(sql);
1.8 veillard 347: insert = mysql_insert_id(sql);
1.1 veillard 348: if (result) {
349: mysql_free_result(result);
1.8 veillard 350: return(insert);
1.1 veillard 351: }
352: if(mysql_errno(sql)) {
353: fprintf(stderr, "sql_blind_insert Error: %s\n", mysql_error(sql));
354: return(-1);
355: }
1.8 veillard 356: return(insert);
1.1 veillard 357: }
358:
359: int sql_update(const char *table, const char *name,
360: const char *field, const char *value) {
361: MYSQL_RES *result;
362: MYSQL_ROW row;
1.6 veillard 363: char query[MAX_QUERY];
1.1 veillard 364: int id;
365: int nb_fields = 0;
1.6 veillard 366: int left = MAX_QUERY - 1;
367: int len;
368: char *end;
1.1 veillard 369:
370: if ((name == NULL) || (table == NULL) ||
371: (field == NULL) || (value == NULL))
372: return(-1);
373:
374: /*
375: * Search first for the ID if it already exists
376: */
1.6 veillard 377: snprintf(query, MAX_QUERY - 1, "SELECT ID FROM %s WHERE Name='%s'", table, name);
378: query[MAX_QUERY - 1] = 0;
1.1 veillard 379: if (mysql_query(sql,query)) {
380: printf("sql_update: SELECT failed\n");
381: return(-1);
382: }
383:
384: result = mysql_use_result(sql);
385: if (result) {
386: while((row = mysql_fetch_row(result)))
387: {
388: if (row[0] == NULL) {
389: printf("sql_update: select ID for %s returns NULL !\n", name);
390: return(-1);
391: }
392: if (sscanf(row[0], "%d", &id) != 1) {
393: printf("sql_update: ID non numeric %s\n", row[0]);
394: return(-1);
395: }
1.6 veillard 396:
397: left = MAX_QUERY - 1;
398: len = snprintf(query, left, "UPDATE %s SET %s='", table, field);
399: if (len < 0) {
400: fprintf(stderr, "sql_update : %s(%d).%s overflow\n",
401: table, id, field);
402: return(-1);
403: }
404: end = &query[len];
405: left -= len;
406: len = strlen(value);
407: if (len * 2 >= left) {
408: fprintf(stderr, "sql_update : %s(%d).%s overflow\n",
409: table, id, field);
410: return(-1);
411: }
412: len = mysql_escape_string(end, value, len);
413: left -= len;
414: if (left <= 0) {
415: fprintf(stderr, "sql_update : %s(%d).%s overflow\n",
416: table, id, field);
417: return(-1);
418: }
419: end += len;
420: len = snprintf(end, left, "' WHERE ID=%d", id);
421: if (len < 0) {
422: fprintf(stderr, "sql_update : %s(%d).%s overflow\n",
423: table, id, field);
424: return(-1);
425: }
426: end += len;
427: query[MAX_QUERY - 1] = 0;
428:
1.1 veillard 429: mysql_free_result(result);
1.16 veillard 430: if (do_sql_query(query, (unsigned int) (end - query))) {
1.2 veillard 431: printf("sql_update: UPDATE failed: %s\n", mysql_error(sql));
1.1 veillard 432: return(-1);
433: }
434: result = mysql_store_result(sql);
435: if (result != NULL) {
436: nb_fields = mysql_num_fields(result);
437: mysql_free_result(result);
438: } else {
1.2 veillard 439: return(1);
1.1 veillard 440: }
441: /* Do not loop ... only the first */
442: return(nb_fields);
443: }
444: mysql_free_result(result);
1.2 veillard 445: if (nb_fields == 0) {
446: /*
447: * Propagate an insert
448: */
1.6 veillard 449: snprintf(query, MAX_QUERY - 1,
1.2 veillard 450: "INSERT INTO %s (Name,%s) VALUES ('%s','%s')",
451: table, field, name, value);
1.6 veillard 452: query[MAX_QUERY - 1] = 0;
1.2 veillard 453: mysql_free_result(result);
454: if (mysql_query(sql, query)) {
455: printf("sql_update: INSERT failed: %s\n", mysql_error(sql));
456: return(-1);
457: }
458: result = mysql_store_result(sql);
459: if (result != NULL) {
460: nb_fields = mysql_num_fields(result);
461: mysql_free_result(result);
462: } else {
463: return(1);
464: }
465: }
1.1 veillard 466: }
467: if(mysql_errno(sql)) {
468: fprintf(stderr, "sql_update Error: %s\n", mysql_error(sql));
469: return(-1);
470: }
471: return(nb_fields);
472: }
473:
1.6 veillard 474: int sql_get_key(const char *table, const char *name, const char *value) {
1.1 veillard 475: int id;
476: MYSQL_RES *result;
477: MYSQL_ROW row;
1.38 veillard 478: char query[MAX_QUERY];
479: int left = MAX_QUERY - 1;
480: int len;
481: char *end;
1.1 veillard 482:
483: if ((table == NULL) || (name == NULL))
484: return(-1);
485:
1.38 veillard 486:
1.1 veillard 487: /*
488: * Search first for the ID if it already exists
489: */
1.38 veillard 490: len = snprintf(query, left, "SELECT ID FROM %s WHERE %s='",
491: table, name);
492: if (len < 0) {
493: fprintf(stderr, "sql_get_key : %s(%s).%s overflow\n",
494: table, name, value);
495: return(-1);
496: }
497: end = &query[len];
498: left -= len;
499: len = strlen(value);
500: if (len * 2 >= left) {
501: fprintf(stderr, "sql_get_key : %s(%s).%s overflow\n",
502: table, name, value);
503: return(-1);
504: }
505: len = mysql_escape_string(end, value, len);
506: left -= len;
507: if (left <= 0) {
508: fprintf(stderr, "sql_get_key : %s(%s).%s overflow\n",
509: table, name, value);
510: return(-1);
511: }
512: end += len;
513: len = snprintf(end, left, "'");
514: if (len < 0) {
515: fprintf(stderr, "sql_get_key : %s(%s).%s overflow\n",
516: table, name, value);
517: return(-1);
518: }
519: end += len;
520: query[MAX_QUERY - 1] = 0;
521:
1.1 veillard 522: if (mysql_query(sql,query)) {
1.38 veillard 523: printf("sql_get_key: SELECT %s failed %s\n", name, mysql_error(sql));
1.1 veillard 524: return(-1);
525: }
526:
527: result = mysql_use_result(sql);
528: if (result) {
529: while((row = mysql_fetch_row(result)))
530: {
531: /*
532: * Lookup the first ID and return it
533: */
534: if (row[0] == NULL) {
535: mysql_free_result(result);
1.38 veillard 536: printf("sql_get_key: select returns NULL !\n");
1.1 veillard 537: return(-1);
538: }
539: if (sscanf(row[0], "%d", &id) != 1) {
540: mysql_free_result(result);
1.38 veillard 541: printf("sql_get_key: ID non numeric %s\n", row[0]);
1.1 veillard 542: return(-1);
543: }
544: mysql_free_result(result);
545: return(id);
546: }
547: mysql_free_result(result);
548: }
549: if(mysql_errno(sql)) {
550: fprintf(stderr, "Error: %s\n", mysql_error(sql));
551: return(-1);
552: }
553:
554: /*
555: * Do a creation
556: */
557:
1.6 veillard 558: query[SMALL_QUERY - 1] = 0;
1.38 veillard 559: len = snprintf(query, left, "INSERT INTO %s (%s) VALUES ('",
560: table, name);
561: if (len < 0) {
562: fprintf(stderr, "sql_get_key : %s(%s).%s overflow\n",
563: table, name, value);
564: return(-1);
565: }
566: end = &query[len];
567: left -= len;
568: len = strlen(value);
569: if (len * 2 >= left) {
570: fprintf(stderr, "sql_get_key : %s(%s).%s overflow\n",
571: table, name, value);
572: return(-1);
573: }
574: len = mysql_escape_string(end, value, len);
575: left -= len;
576: if (left <= 0) {
577: fprintf(stderr, "sql_get_key : %s(%s).%s overflow\n",
578: table, name, value);
579: return(-1);
580: }
581: end += len;
582: len = snprintf(end, left, "')");
583: if (len < 0) {
584: fprintf(stderr, "sql_get_key : %s(%s).%s overflow\n",
585: table, name, value);
586: return(-1);
587: }
588: end += len;
589: query[MAX_QUERY - 1] = 0;
590:
1.1 veillard 591: if (mysql_query(sql,query)) {
1.2 veillard 592: printf("sql_get_key: INSERT %s failed %s\n", name, mysql_error(sql));
1.1 veillard 593: return(-1);
594: }
595: id = mysql_insert_id(sql);
596: result = mysql_store_result(sql);
597: if (result != NULL)
598: mysql_free_result(result);
599: return(id);
600: }
601:
602: int sql_read_key(const char *table, const char *name) {
603: int id;
604: MYSQL_RES *result;
605: MYSQL_ROW row;
1.6 veillard 606: char query[SMALL_QUERY];
1.1 veillard 607:
608: if ((table == NULL) || (name == NULL))
609: return(-1);
610:
611: /*
612: * Search for the ID it has to exist
613: */
1.6 veillard 614: snprintf(query, SMALL_QUERY - 1, "SELECT ID FROM %s WHERE Name='%s'", table, name);
615: query[SMALL_QUERY - 1] = 0;
1.2 veillard 616: if (mysql_query(sql,query)) {
1.38 veillard 617: printf("sql_read_key: SELECT %s failed %s\n", name, mysql_error(sql));
1.2 veillard 618: return(-1);
619: }
620:
621: result = mysql_use_result(sql);
622: if (result) {
623: while((row = mysql_fetch_row(result)))
624: {
625: /*
626: * Lookup the first ID and return it
627: */
628: if (row[0] == NULL) {
629: mysql_free_result(result);
1.38 veillard 630: printf("sql_read_key: select returns NULL !\n");
1.2 veillard 631: return(-1);
632: }
633: if (sscanf(row[0], "%d", &id) != 1) {
634: mysql_free_result(result);
1.38 veillard 635: printf("sql_read_key: ID non numeric %s\n", row[0]);
1.2 veillard 636: return(-1);
637: }
638: mysql_free_result(result);
639: return(id);
640: }
641: mysql_free_result(result);
642: }
643: if(mysql_errno(sql)) {
644: fprintf(stderr, "Error: %s\n", mysql_error(sql));
645: return(-1);
646: }
647: return(-1);
648: }
649:
650: int sql_read_info_key(const char *table, const char *name, const char *value) {
651: int id;
652: MYSQL_RES *result;
653: MYSQL_ROW row;
1.6 veillard 654: char query[SMALL_QUERY];
1.2 veillard 655:
656: if ((table == NULL) || (name == NULL) || (value == NULL))
657: return(-1);
658:
659: /*
660: * Search for the ID it has to exist
661: */
1.6 veillard 662: snprintf(query, SMALL_QUERY - 1, "SELECT ID FROM %s WHERE %s='%s'", table, name, value);
663: query[SMALL_QUERY - 1] = 0;
1.1 veillard 664: if (mysql_query(sql,query)) {
1.38 veillard 665: printf("sql_read_info_key: SELECT %s failed %s\n", name, mysql_error(sql));
1.1 veillard 666: return(-1);
667: }
668:
669: result = mysql_use_result(sql);
670: if (result) {
671: while((row = mysql_fetch_row(result)))
672: {
673: /*
674: * Lookup the first ID and return it
675: */
676: if (row[0] == NULL) {
677: mysql_free_result(result);
1.38 veillard 678: printf("sql_read_info_key: select returns NULL !\n");
1.1 veillard 679: return(-1);
680: }
681: if (sscanf(row[0], "%d", &id) != 1) {
682: mysql_free_result(result);
1.38 veillard 683: printf("sql_read_info_key: ID non numeric %s\n", row[0]);
1.1 veillard 684: return(-1);
685: }
686: mysql_free_result(result);
687: return(id);
688: }
689: mysql_free_result(result);
690: }
691: if(mysql_errno(sql)) {
692: fprintf(stderr, "Error: %s\n", mysql_error(sql));
693: return(-1);
694: }
695: return(-1);
696: }
697:
698: /************************************************************************
699: * *
700: * Tables handling *
701: * *
702: ************************************************************************/
703:
1.2 veillard 704: int sql_rebuild_config(void) {
705: const char *query =
706: "CREATE TABLE Config ( \n\
707: ID int(11) NOT NULL auto_increment, \n\
708: Name varchar(50) NOT NULL, \n\
709: Value varchar(255), \n\
710: PRIMARY KEY (ID), \n\
711: KEY Name (Name(10)) \n\
712: )";
713:
714: if (mysql_query(sql,query)) {
715: printf("sql_rebuild_config: CREATE TABLE Config failed %s\n",
716: mysql_error(sql));
717: return(-1);
718: }
719: return(0);
720: }
721:
1.1 veillard 722: int sql_rebuild_vendors(void) {
723: const char *query =
724: "CREATE TABLE Vendors ( \n\
725: ID int(11) NOT NULL auto_increment, \n\
726: Name varchar(255) NOT NULL, \n\
727: URL varchar(255), \n\
728: Key1 text, \n\
729: Key2 text, \n\
730: Key3 text, \n\
731: Description text, \n\
732: PRIMARY KEY (ID), \n\
733: KEY Name (Name(10)) \n\
734: )";
735:
736: if (mysql_query(sql,query)) {
1.2 veillard 737: printf("sql_rebuild_vendors: CREATE TABLE Vendors failed %s\n",
1.1 veillard 738: mysql_error(sql));
739: return(-1);
740: }
741: return(0);
742: }
743:
1.36 veillard 744: int sql_rebuild_distributions(void) {
745: const char *query =
746: "CREATE TABLE Distributions ( \n\
747: ID int(11) NOT NULL auto_increment, \n\
748: Name varchar(255) NOT NULL, \n\
749: URL varchar(255), \n\
750: Key1 text, \n\
751: Key2 text, \n\
752: Key3 text, \n\
753: Description text, \n\
754: PRIMARY KEY (ID), \n\
755: KEY Name (Name(10)) \n\
756: )";
757:
758: if (mysql_query(sql,query)) {
759: printf("sql_rebuild_ditributions: CREATE TABLE Distributions failed %s\n",
760: mysql_error(sql));
761: return(-1);
762: }
763: return(0);
764: }
765:
1.1 veillard 766: int sql_rebuild_mirrors(void) {
767: const char *query =
768: "CREATE TABLE Mirrors ( \n\
769: ID int(11), \n\
770: URL varchar(255) NOT NULL, \n\
771: Country int(11), \n\
772: UNIQUE(URL) \n\
773: )";
774:
775: if (mysql_query(sql,query)) {
1.2 veillard 776: printf("sql_rebuild_mirrors: CREATE TABLE Mirrors failed %s\n",
777: mysql_error(sql));
778: return(-1);
779: }
780: return(0);
781: }
782:
783: int sql_rebuild_metadata(void) {
784: const char *query =
785: "CREATE TABLE Metadata ( \n\
786: URL varchar(255) NOT NULL, \n\
787: Maintainer int(11), \n\
788: Country int(11), \n\
789: UNIQUE(URL) \n\
790: )";
791:
792: if (mysql_query(sql,query)) {
793: printf("sql_rebuild_metadata: CREATE TABLE Metadata failed %s\n",
1.1 veillard 794: mysql_error(sql));
795: return(-1);
796: }
797: return(0);
798: }
799:
800: int sql_rebuild_distribs(void) {
801: const char *query =
802: "CREATE TABLE Distribs ( \n\
803: ID int(11) NOT NULL auto_increment, \n\
804: Name varchar(255) NOT NULL, \n\
805: Vendor int(11), \n\
1.2 veillard 806: Directory varchar(255), \n\
1.1 veillard 807: Path varchar(100) NOT NULL, \n\
808: URL varchar(255), \n\
809: URLSrc varchar(255), \n\
1.9 veillard 810: Html varchar(8), \n\
811: Color varchar(10), \n\
1.1 veillard 812: Key1 text, \n\
813: Key2 text, \n\
814: Description text, \n\
815: PRIMARY KEY (ID), \n\
816: KEY Name (Name(10)) \n\
817: )";
818:
819: if (mysql_query(sql,query)) {
1.2 veillard 820: printf("sql_rebuild_distribs: CREATE TABLE Distribs failed %s\n",
821: mysql_error(sql));
822: return(-1);
823: }
824: return(0);
825: }
826:
827: int sql_rebuild_packages(void) {
828: const char *query =
829: "CREATE TABLE Packages ( \n\
830: ID int(11) NOT NULL auto_increment, \n\
831: filename varchar(255) NOT NULL, \n\
832: Name varchar(50) NOT NULL, \n\
833: Version varchar(50) NOT NULL, \n\
834: Release varchar(50) NOT NULL, \n\
1.6 veillard 835: Arch varchar(15) NOT NULL, \n\
1.2 veillard 836: Dist int(11), \n\
837: URL varchar(255), \n\
838: URLSrc varchar(255), \n\
839: Vendor int(11), \n\
840: Packager int(11), \n\
841: Category varchar(255), \n\
842: Summary varchar(255), \n\
843: Description text, \n\
844: Copyright varchar(255), \n\
1.25 veillard 845: Date int(11), \n\
1.41 ! veillard 846: Size int(11), \n\
1.33 veillard 847: Os varchar(12), \n\
1.2 veillard 848: PRIMARY KEY (ID), \n\
1.7 veillard 849: KEY filename (filename(80)), \n\
850: KEY Name (Name(15)) \n\
1.2 veillard 851: )";
852:
853: if (mysql_query(sql,query)) {
854: printf("sql_rebuild_packages: CREATE TABLE Packages failed %s\n",
855: mysql_error(sql));
856: return(-1);
857: }
858: return(0);
859: }
860:
861: int sql_rebuild_files(void) {
862: const char *query =
863: "CREATE TABLE Files ( \n\
1.6 veillard 864: ID int(11) NOT NULL, \n\
1.7 veillard 865: Path varchar(35) NOT NULL, \n\
866: UNIQUE KEY id (ID,Path(35)), \n\
1.6 veillard 867: INDEX (ID), \n\
868: INDEX (Path) \n\
1.2 veillard 869: )";
870:
871: if (mysql_query(sql,query)) {
872: printf("sql_rebuild_files: CREATE TABLE Files failed %s\n",
1.1 veillard 873: mysql_error(sql));
874: return(-1);
875: }
876: return(0);
877: }
878:
1.8 veillard 879: int sql_rebuild_provides(void) {
880: const char *query =
881: "CREATE TABLE Provides ( \n\
882: ID int(11) NOT NULL, \n\
883: Resource varchar(35) NOT NULL, \n\
884: UNIQUE KEY id (ID,Resource(35)), \n\
885: INDEX (ID), \n\
886: INDEX (Resource) \n\
887: )";
888:
889: if (mysql_query(sql,query)) {
1.21 daniel 890: printf("sql_rebuild_provides: CREATE TABLE Provides failed %s\n",
1.8 veillard 891: mysql_error(sql));
892: return(-1);
893: }
894: return(0);
895: }
896:
897: int sql_rebuild_requires(void) {
898: const char *query =
899: "CREATE TABLE Requires ( \n\
900: ID int(11) NOT NULL, \n\
901: Resource varchar(35) NOT NULL, \n\
902: Rel char(2), \n\
903: Value varchar(20), \n\
904: UNIQUE KEY id (ID,Resource(35)), \n\
905: INDEX (ID), \n\
906: INDEX (Resource) \n\
907: )";
908:
909: if (mysql_query(sql,query)) {
1.21 daniel 910: printf("sql_rebuild_requires: CREATE TABLE Requires failed %s\n",
911: mysql_error(sql));
912: return(-1);
913: }
914: return(0);
915: }
916:
917: int sql_rebuild_queries(void) {
918: const char *query =
919: "CREATE TABLE Queries ( \n\
920: ID int(11) NOT NULL auto_increment,\n\
921: Value varchar(50) NOT NULL, \n\
922: Count int(11) NOT NULL, \n\
923: Results int(11) NOT NULL, \n\
924: UNIQUE KEY id (ID,Value(35)), \n\
925: INDEX (ID), \n\
926: INDEX (Value) \n\
927: )";
928:
929: if (mysql_query(sql,query)) {
930: printf("sql_rebuild_queries: CREATE TABLE Queries failed %s\n",
1.8 veillard 931: mysql_error(sql));
932: return(-1);
933: }
934: return(0);
935: }
936:
1.1 veillard 937:
938: int sql_check_tables(void) {
939: const char *query = "SHOW TABLES";
940: MYSQL_RES *result;
941: MYSQL_ROW row;
1.2 veillard 942: int config = 0;
1.1 veillard 943: int distribs = 0;
1.8 veillard 944: int requires = 0;
945: int provides = 0;
1.1 veillard 946: int vendors = 0;
947: int mirrors = 0;
1.2 veillard 948: int metadata = 0;
949: int packages = 0;
950: int files = 0;
1.21 daniel 951: int queries = 0;
1.36 veillard 952: int distributions = 0;
1.2 veillard 953:
1.1 veillard 954: int rebuilt = 0;
955:
956: if (mysql_query(sql,query)) {
1.2 veillard 957: printf("sql_check_tables: SHOW TABLES failed %s\n",
1.1 veillard 958: mysql_error(sql));
959: return(-1);
960: }
961:
962: result = mysql_use_result(sql);
963: if (result) {
964: while((row = mysql_fetch_row(result)))
965: {
966: if (row[0] == NULL) {
967: mysql_free_result(result);
968: printf("sql_check_tables: SHOW TABLES returns NULL !\n");
969: return(-1);
970: }
1.2 veillard 971: if (!strcmp(row[0], "Config"))
972: config = 1;
1.1 veillard 973: if (!strcmp(row[0], "Distribs"))
974: distribs = 1;
975: if (!strcmp(row[0], "Vendors"))
976: vendors = 1;
977: if (!strcmp(row[0], "Mirrors"))
978: mirrors = 1;
1.2 veillard 979: if (!strcmp(row[0], "Metadata"))
980: metadata = 1;
981: if (!strcmp(row[0], "Packages"))
982: packages = 1;
983: if (!strcmp(row[0], "Files"))
984: files = 1;
1.8 veillard 985: if (!strcmp(row[0], "Requires"))
986: requires = 1;
987: if (!strcmp(row[0], "Provides"))
988: provides = 1;
1.21 daniel 989: if (!strcmp(row[0], "Queries"))
990: queries = 1;
1.36 veillard 991: if (!strcmp(row[0], "Distributions"))
992: distributions = 1;
1.1 veillard 993: }
994: mysql_free_result(result);
995: }
996: if(mysql_errno(sql)) {
997: fprintf(stderr, "Error: %s\n", mysql_error(sql));
998: return(-1);
999: }
1000:
1.2 veillard 1001: if (!config) {
1002: fprintf(stderr, "Table Config disapeared: rebuilding it\n");
1003: if (!sql_rebuild_config())
1004: rebuilt++;
1005: }
1.1 veillard 1006: if (!vendors) {
1007: fprintf(stderr, "Table Vendors disapeared: rebuilding it\n");
1008: if (!sql_rebuild_vendors())
1009: rebuilt++;
1010: }
1011: if (!distribs) {
1012: fprintf(stderr, "Table Distribs disapeared: rebuilding it\n");
1013: if (!sql_rebuild_distribs())
1014: rebuilt++;
1015: }
1016: if (!mirrors) {
1017: fprintf(stderr, "Table Mirrors disapeared: rebuilding it\n");
1018: if (!sql_rebuild_mirrors())
1019: rebuilt++;
1020: }
1.2 veillard 1021: if (!metadata) {
1022: fprintf(stderr, "Table Metadata disapeared: rebuilding it\n");
1023: if (!sql_rebuild_metadata())
1024: rebuilt++;
1025: }
1026: if (!packages) {
1027: fprintf(stderr, "Table Packages disapeared: rebuilding it\n");
1028: if (!sql_rebuild_packages())
1029: rebuilt++;
1030: }
1031: if (!files) {
1032: fprintf(stderr, "Table Files disapeared: rebuilding it\n");
1033: if (!sql_rebuild_files())
1034: rebuilt++;
1035: }
1.8 veillard 1036: if (!requires) {
1037: fprintf(stderr, "Table Requires disapeared: rebuilding it\n");
1038: if (!sql_rebuild_requires())
1039: rebuilt++;
1040: }
1041: if (!provides) {
1042: fprintf(stderr, "Table Provides disapeared: rebuilding it\n");
1043: if (!sql_rebuild_provides())
1.21 daniel 1044: rebuilt++;
1045: }
1046: if (!queries) {
1047: fprintf(stderr, "Table Queries disapeared: rebuilding it\n");
1048: if (!sql_rebuild_queries())
1.8 veillard 1049: rebuilt++;
1050: }
1.36 veillard 1051: if (!distributions) {
1052: fprintf(stderr, "Table Distributions disapeared: rebuilding it\n");
1053: if (!sql_rebuild_distributions())
1054: rebuilt++;
1055: }
1.1 veillard 1056: return(rebuilt);
1057: }
1058:
1059: /************************************************************************
1060: * *
1061: * Specific rpm2html functions *
1062: * *
1063: ************************************************************************/
1064:
1.5 veillard 1065: int sql_add_dist_mirror(int distrib, const char *URL, int country) {
1.1 veillard 1066: if (URL == NULL)
1067: return(-1);
1068: if (distrib < 0)
1069: return(-1);
1070: return(sql_blind_insert("Mirrors", "URL", URL, distrib));
1071: }
1072:
1.5 veillard 1073: int sql_add_mirror(const char *Name, const char *URL, int country) {
1.1 veillard 1074: int distrib;
1075:
1076: if ((Name == NULL) || (URL == NULL))
1077: return(-1);
1078: distrib = sql_read_key("Distribs", Name);
1079: if (distrib < 0)
1080: return(distrib);
1081: return(sql_blind_insert("Mirrors", "URL", URL, distrib));
1082: }
1083:
1.6 veillard 1084: int sql_add_file(const char *filename, int package) {
1085: if ((filename == NULL) || (package <= 0))
1086: return(-1);
1.7 veillard 1087: if (strlen(filename) > 35)
1088: return(0);
1.6 veillard 1089:
1090: return(sql_blind_insert("Files", "Path", filename, package));
1091: }
1092:
1.8 veillard 1093: int sql_add_provides(int package, const char *resource) {
1094: if ((resource == NULL) || (package <= 0))
1095: return(-1);
1096: if (strlen(resource) > 35)
1097: return(0);
1098:
1099: return(sql_blind_insert("Provides", "Resource", resource, package));
1100: }
1101:
1.14 veillard 1102: int sql_add_requires(int package, const char *resource, rpm_dep_flag rel,
1.8 veillard 1103: const char *value) {
1104: int record;
1105: if ((resource == NULL) || (package <= 0))
1106: return(-1);
1107: if (strlen(resource) > 35)
1108: return(0);
1109:
1110: record = sql_blind_insert("Requires", "Resource", resource, package);
1.14 veillard 1111: if ((rel != RPM2HTML_REQ_NONE) && (value != NULL) &&
1112: (strlen(value) <= 50)) {
1.8 veillard 1113: char query[SMALL_QUERY];
1.14 veillard 1114:
1115: switch (rel) {
1116: case RPM2HTML_REQ_LT:
1117: snprintf(query, SMALL_QUERY - 1,
1118: "UPDATE Requires SET Rel='<',Value='%s' WHERE ID=%d",
1119: value, record);
1.15 daniel 1120: break;
1.14 veillard 1121: case RPM2HTML_REQ_LEQ:
1122: snprintf(query, SMALL_QUERY - 1,
1123: "UPDATE Requires SET Rel='<=',Value='%s' WHERE ID=%d",
1124: value, record);
1.15 daniel 1125: break;
1.14 veillard 1126: case RPM2HTML_REQ_GT:
1127: snprintf(query, SMALL_QUERY - 1,
1128: "UPDATE Requires SET Rel='>',Value='%s' WHERE ID=%d",
1129: value, record);
1.15 daniel 1130: break;
1.14 veillard 1131: case RPM2HTML_REQ_GEQ:
1132: snprintf(query, SMALL_QUERY - 1,
1133: "UPDATE Requires SET Rel='>=',Value='%s' WHERE ID=%d",
1134: value, record);
1.15 daniel 1135: break;
1.14 veillard 1136: case RPM2HTML_REQ_EQU:
1137: snprintf(query, SMALL_QUERY - 1,
1138: "UPDATE Requires SET Rel='=',Value='%s' WHERE ID=%d",
1139: value, record);
1.15 daniel 1140: break;
1.14 veillard 1141: case RPM2HTML_REQ_NONE:
1142: query[0] = 0;
1143: }
1.8 veillard 1144: query[SMALL_QUERY - 1] = 0;
1145: if (mysql_query(sql,query)) {
1.38 veillard 1146: printf("sql_add_requires: UPDATE Requires %d failed %s\n",
1.8 veillard 1147: record, mysql_error(sql));
1148: return(record);
1149: }
1150: }
1151: return(record);
1152: }
1153:
1.34 veillard 1154: int sql_add_vendor(const char *Name, const char *URL, const char *Description) {
1155: int id;
1156:
1157: if (Name == NULL)
1158: return(-1);
1159:
1160: id = sql_get_key("Vendors", "Name", Name);
1161: if (id <= 0) {
1162: id = sql_blind_insert("Vendors", "Name", Name, 0);
1163: if (id <= 0)
1164: return(id);
1165: }
1166: if (URL != NULL)
1167: sql_update_id("Vendors", id, "URL", URL);
1168: if (Description != NULL)
1169: sql_update_id("Vendors", id,
1170: "Description", Description);
1171:
1172: return(id);
1173: }
1174:
1.36 veillard 1175: int sql_add_distribution(const char *Name, const char *URL, const char *Description) {
1176: int id;
1177:
1178: if (Name == NULL)
1179: return(-1);
1180:
1181: id = sql_get_key("Distributions", "Name", Name);
1182: if (id <= 0) {
1183: id = sql_blind_insert("Distributions", "Name", Name, 0);
1184: if (id <= 0)
1185: return(id);
1186: }
1187: if (URL != NULL)
1188: sql_update_id("Distributions", id, "URL", URL);
1189: if (Description != NULL)
1190: sql_update_id("Distributions", id,
1191: "Description", Description);
1192:
1193: return(id);
1194: }
1195:
1.34 veillard 1196:
1.5 veillard 1197: int sql_add_package(const char *filename,
1.2 veillard 1198: const char *Name, const char *Version, const char *Release,
1.6 veillard 1199: const char *Arch,
1200: int dist, const char *URL, const char *URLSrc, int vendor,
1.2 veillard 1201: const char *Packager, const char *Category, const char *Summary,
1.41 ! veillard 1202: const char *Description, const char *Copyright, int Date, int Size,
1.36 veillard 1203: const char *Os, const char *Distribution) {
1.2 veillard 1204: int id;
1205: int nb_fields = 0;
1.35 veillard 1206: char installed_filename[500];
1.2 veillard 1207:
1.35 veillard 1208: if (filename == NULL) {
1209: sprintf(installed_filename, "localbase/%s-%s-%s.%s.rpm",
1210: Name,Version,Release,Arch);
1211: filename = installed_filename;
1212: }
1.6 veillard 1213:
1214: if (dist < 0)
1.2 veillard 1215: return(-1);
1.6 veillard 1216: if ((Name == NULL) || (Version == NULL) || (Release == NULL) ||
1217: (Arch == NULL))
1218: return(-1);
1219:
1220: id = sql_get_key("Packages", "filename", filename);
1.2 veillard 1221: if (id <= 0)
1222: return(-1);
1223: nb_fields = 1;
1.8 veillard 1224:
1225: if (rpm2htmlVerbose > 1)
1226: printf("Adding %s ID %d\n", filename, id);
1227:
1.2 veillard 1228: if (Name != NULL)
1.6 veillard 1229: nb_fields += sql_update_id("Packages", id, "Name", Name);
1.2 veillard 1230: if (Version != NULL)
1231: nb_fields += sql_update_id("Packages", id, "Version", Version);
1232: if (Release != NULL)
1233: nb_fields += sql_update_id("Packages", id, "Release", Release);
1.6 veillard 1234: if (Release != NULL)
1235: nb_fields += sql_update_id("Packages", id, "Arch", Arch);
1.2 veillard 1236: if (Category != NULL)
1237: nb_fields += sql_update_id("Packages", id, "Category", Category);
1238: if (URL != NULL)
1239: nb_fields += sql_update_id("Packages", id, "URL", URL);
1240: if (URLSrc != NULL)
1241: nb_fields += sql_update_id("Packages", id, "URLSrc", URLSrc);
1.17 veillard 1242: if (dist >= 0) {
1243: char str[30];
1244: snprintf(str, 30, "%d", dist);
1245: str[29] = 0;
1246: nb_fields += sql_update_id("Packages", id, "Dist", str);
1247: }
1.38 veillard 1248: if (Summary != NULL) {
1.2 veillard 1249: nb_fields += sql_update_id("Packages", id, "Summary", Summary);
1.38 veillard 1250: }
1251: if (Description != NULL) {
1.2 veillard 1252: nb_fields += sql_update_id("Packages", id,
1253: "Description", Description);
1.38 veillard 1254: }
1.2 veillard 1255: if (Copyright != NULL)
1256: nb_fields += sql_update_id("Packages", id, "Copyright", Copyright);
1.25 veillard 1257: if (Date != 0) {
1258: char str[30];
1259: snprintf(str, 30, "%d", Date);
1260: str[29] = 0;
1261: nb_fields += sql_update_id("Packages", id, "Date", str);
1262: }
1.41 ! veillard 1263: if (Size != 0) {
! 1264: char str[30];
! 1265: snprintf(str, 30, "%d", Size);
! 1266: str[29] = 0;
! 1267: nb_fields += sql_update_id("Packages", id, "Size", str);
! 1268: }
1.38 veillard 1269: if (Os != NULL) {
1.33 veillard 1270: nb_fields += sql_update_id("Packages", id, "Os", Os);
1.38 veillard 1271: }
1.34 veillard 1272: if (Packager != NULL) {
1273: char str[30];
1.35 veillard 1274: int packager = sql_add_vendor(Packager, NULL, NULL);
1.34 veillard 1275:
1.35 veillard 1276: if (packager > 0) {
1277: snprintf(str, 30, "%d", packager);
1.34 veillard 1278: str[29] = 0;
1.35 veillard 1279: nb_fields += sql_update_id("Packages", id, "Packager", str);
1.34 veillard 1280: }
1281: }
1.36 veillard 1282: if (Distribution != NULL) {
1283: char str[30];
1284: int packager = sql_add_distribution(Distribution, NULL, NULL);
1285:
1286: if (packager > 0) {
1287: snprintf(str, 30, "%d", packager);
1288: str[29] = 0;
1289: nb_fields += sql_update_id("Packages", id, "Vendor", str);
1290: }
1291: }
1292: /***************
1293: if (vendor > 0) {
1294: char str[30];
1295: snprintf(str, 30, "%d", vendor);
1296: str[29] = 0;
1297: nb_fields += sql_update_id("Packages", id, "Vendor", str);
1298: }
1299: ***************/
1.2 veillard 1300:
1.6 veillard 1301: return(id);
1.17 veillard 1302: }
1303:
1304: int sql_get_distrib_by_name(const char *Name) {
1305: int ret;
1306:
1307: if (Name == NULL)
1308: return(-1);
1309: ret = sql_read_key("Distribs", Name);
1310:
1.18 daniel 1311: #ifdef SQL_DEBUG
1.17 veillard 1312: fprintf(stderr, "sql_get_distrib_by_name(%s) => %d\n", Name, ret);
1.18 daniel 1313: #endif
1.17 veillard 1314:
1315: return(ret);
1316: }
1317:
1318: int sql_get_distrib_by_directory(const char *Directory) {
1319: int ret;
1320:
1321: if (Directory == NULL)
1322: return(-1);
1323:
1324: ret = sql_get_key("Distribs", "Directory", Directory);
1325:
1.18 daniel 1326: #ifdef SQL_DEBUG
1.17 veillard 1327: fprintf(stderr, "sql_get_distrib_by_directory(%s) => %d\n", Directory, ret);
1.18 daniel 1328: #endif
1.17 veillard 1329:
1330: return(ret);
1.2 veillard 1331: }
1332:
1.5 veillard 1333: int sql_add_distrib(const char *Name, const char *Vendor,
1.2 veillard 1334: const char *Directory, const char *Path, const char *URL,
1.9 veillard 1335: const char *URLSrc, const char *Description,
1336: const char *Html, const char *Color) {
1.1 veillard 1337: int id, vendor;
1338: int nb_fields = 0;
1339: char VendorStr[15];
1340:
1341: if (Name == NULL)
1342: return(-1);
1343:
1.6 veillard 1344: id = sql_get_key("Distribs", "Name", Name);
1.1 veillard 1345: nb_fields = 1;
1346: if (Vendor != NULL) {
1.6 veillard 1347: vendor = sql_get_key("Vendors", "Name", Vendor);
1.1 veillard 1348: sprintf(VendorStr, "%d", vendor);
1349: nb_fields += sql_update_id("Distribs", id, "Vendor", VendorStr);
1350: }
1.2 veillard 1351: if (Directory != NULL)
1352: nb_fields += sql_update_id("Distribs", id, "Directory", Directory);
1.1 veillard 1353: if (Path != NULL)
1354: nb_fields += sql_update_id("Distribs", id, "Path", Path);
1355: if (URL != NULL)
1356: nb_fields += sql_update_id("Distribs", id, "URL", URL);
1357: if (URLSrc != NULL)
1358: nb_fields += sql_update_id("Distribs", id, "URLSrc", URLSrc);
1.9 veillard 1359: if (Html != NULL)
1360: nb_fields += sql_update_id("Distribs", id, "Html", Html);
1361: if (Color != NULL)
1362: nb_fields += sql_update_id("Distribs", id, "Color", Color);
1.1 veillard 1363: if (Description != NULL)
1364: nb_fields += sql_update_id("Distribs", id,
1365: "Description", Description);
1366:
1367: return(nb_fields);
1368: }
1369:
1.5 veillard 1370: void sql_add_config_info(const char *name, const char *value) {
1.2 veillard 1371: sql_update("Config", name, "Value", value);
1372: }
1373:
1.5 veillard 1374: void sql_add_metadata_base(const char *URL) {
1.2 veillard 1375: sql_blind_insert("Metadata", "URL", URL, -1);
1376: }
1377:
1.6 veillard 1378: /************************************************************************
1379: * *
1.8 veillard 1380: * Cleanup functions *
1381: * *
1382: ************************************************************************/
1383:
1384: int sql_remove_package(int id) {
1385: char query[SMALL_QUERY];
1386:
1387: if (id <= 0)
1388: return(-1);
1389:
1390: /*
1391: * remove the ID from the package list
1392: */
1393: snprintf(query, SMALL_QUERY - 1, "DELETE FROM Packages WHERE ID=%d", id);
1394: query[SMALL_QUERY - 1] = 0;
1395: if (mysql_query(sql,query)) {
1.38 veillard 1396: printf("sql_remove_package: DELETE package %d failed %s\n", id, mysql_error(sql));
1.8 veillard 1397: return(-1);
1398: }
1399: if(mysql_errno(sql)) {
1400: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1401: return(-1);
1402: }
1403:
1404: /*
1405: * remove the associated files from the Files list
1406: */
1407: snprintf(query, SMALL_QUERY - 1, "DELETE FROM Files WHERE ID=%d", id);
1408: query[SMALL_QUERY - 1] = 0;
1409: if (mysql_query(sql,query)) {
1.38 veillard 1410: printf("sql_remove_package: DELETE Files %d failed %s\n", id, mysql_error(sql));
1.8 veillard 1411: return(-1);
1412: }
1413: if(mysql_errno(sql)) {
1414: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1415: return(-1);
1416: }
1417:
1418: /*
1419: * remove the associated Provides entries
1420: */
1421: snprintf(query, SMALL_QUERY - 1, "DELETE FROM Provides WHERE ID=%d", id);
1422: query[SMALL_QUERY - 1] = 0;
1423: if (mysql_query(sql,query)) {
1.38 veillard 1424: printf("sql_remove_package: DELETE Provides %d failed %s\n", id, mysql_error(sql));
1.8 veillard 1425: return(-1);
1426: }
1427: if(mysql_errno(sql)) {
1428: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1429: return(-1);
1430: }
1431:
1432: /*
1433: * remove the associated Requires entries
1434: */
1435: snprintf(query, SMALL_QUERY - 1, "DELETE FROM Requires WHERE ID=%d", id);
1436: query[SMALL_QUERY - 1] = 0;
1437: if (mysql_query(sql,query)) {
1.38 veillard 1438: printf("sql_remove_package: DELETE Requires %d failed %s\n", id, mysql_error(sql));
1.8 veillard 1439: return(-1);
1440: }
1441: if(mysql_errno(sql)) {
1442: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1443: return(-1);
1444: }
1445:
1446: return(-1);
1447: }
1448:
1449: int sql_check_packages(void) {
1450: MYSQL_RES *result;
1451: MYSQL_ROW row;
1.20 daniel 1452: char *query = "SELECT filename,ID FROM Packages";
1.8 veillard 1453: struct stat buf;
1454: int id;
1.22 daniel 1455: int ids[2500]; /* Do not remove more than 2500 package per run */
1.8 veillard 1456: int index;
1457: int total = 0;
1458:
1459: if (rpm2htmlVerbose)
1460: printf("Database cleanup\n");
1461: index = 0;
1462: /*
1463: * Search first for the ID if it already exists
1464: */
1465: if (mysql_query(sql,query)) {
1466: printf("sql_check_packages: SELECT from Packages failed: %s\n",
1467: mysql_error(sql));
1468: return(-1);
1469: }
1470:
1471: result = mysql_use_result(sql);
1472: if (result) {
1473: while((row = mysql_fetch_row(result)))
1474: {
1475: if ((row[0] == NULL) || (row[1] == NULL)) {
1476: printf("sql_check_packages: Path or ID is NULL !\n");
1477: continue;
1478: }
1.35 veillard 1479: if (!strncmp(row[0], "localbase", 9))
1480: continue;
1481:
1.8 veillard 1482: if ((stat(row[0], &buf) < 0) || (buf.st_size < 50)) {
1483: /*
1484: * Need to remove the package from the database.
1485: */
1486: if (sscanf(row[1], "%d", &id) != 1) {
1487: printf("sql_check_packages: ID non numeric %s\n", row[1]);
1488: continue;
1489: }
1490: ids[index++] = id;
1.20 daniel 1491: if (rpm2htmlVerbose)
1.8 veillard 1492: printf("Removing %s ID %d\n", row[0], id);
1.22 daniel 1493: if (index >= 2500)
1.8 veillard 1494: break;
1495: }
1496: }
1497: mysql_free_result(result);
1498: }
1499: if(mysql_errno(sql)) {
1500: fprintf(stderr, "sql_update Error: %s\n", mysql_error(sql));
1501: return(-1);
1502: }
1503:
1504: /*
1505: * Do the cleanup.
1506: */
1.20 daniel 1507: if (rpm2htmlVerbose)
1508: printf("Database cleanup : removing %d entries...\n", index);
1.8 veillard 1509: for (id = 0;id < index;id++) {
1510: sql_remove_package(ids[id]);
1511: }
1512:
1.34 veillard 1513: printf("Database cleanup : removed %d entries\n", index);
1.8 veillard 1514: return(total);
1515: }
1516:
1517: /************************************************************************
1.26 veillard 1518: * *
1519: * Package lists extraction *
1520: * *
1521: ************************************************************************/
1522: int sqlDirListInitialized = 0;
1523: rpmDirPtr sqlDirList[SQL_MAX_DISTRIBS];
1.35 veillard 1524: int sqlVendorListInitialized = 0;
1525: int sqlVendorListLen;
1526: char **sqlVendorList;
1.36 veillard 1527: int sqlDistributionListInitialized = 0;
1528: int sqlDistributionListLen;
1529: char **sqlDistributionList;
1.40 veillard 1530: int sqlResourceListInitialized = 0;
1531: int sqlResourceListLen = 0;
1532: int sqlResourceListMax = 0;
1533: char **sqlResourceList;
1534:
1535: char *
1536: sqlRpmAnalyzeResourceRow(MYSQL_ROW row) {
1537: const char *name;
1538: char **tmp, *ret;
1539:
1540: if (row == NULL)
1541: return(NULL);
1542: name = row[0];
1543: if (name == NULL)
1544: return(NULL);
1545:
1546: if (sqlResourceListLen >= sqlResourceListMax) {
1547: sqlResourceListMax *= 2;
1548: tmp = (char **) debugRealloc(sqlResourceList,
1549: (sqlResourceListMax) * sizeof(char *));
1550: if (sqlResourceList == NULL) {
1551: fprintf(stderr, "sqlInitSqlResourceList Error: out of memory\n");
1552: return(NULL);
1553: }
1554: sqlResourceList = tmp;
1555: }
1556:
1557: ret = sqlResourceList[sqlResourceListLen++] = debugStrdup(name);
1558: return(ret);
1559: }
1560:
1561: void
1562: sqlInitSqlResourceList(void) {
1563: MYSQL_RES *result;
1564: MYSQL_ROW row;
1565: char *query;
1566: int i;
1567:
1568: if (sqlResourceListInitialized != 0)
1569: return;
1570:
1571: if (rpm2htmlVerbose)
1572: printf("sqlInitSqlResourceList query\n");
1573:
1574: /*
1575: * Allocate the array
1576: */
1577: sqlResourceListLen = 0;
1578: sqlResourceListMax = 1000;
1579: sqlResourceList = (char **) debugMalloc((sqlResourceListMax) *
1580: sizeof(char *));
1581: if (sqlResourceList == NULL) {
1582: fprintf(stderr, "sqlInitSqlResourceList Error: out of memory\n");
1583: return;
1584: }
1585:
1586: /*
1587: * query the database for the values
1588: */
1589: query = "select Resource from Provides group by Resource";
1590:
1591: if (mysql_query(sql,query)) {
1592: printf("sqlInitSqlResourceList: SELECT from Provides failed: %s\n",
1593: mysql_error(sql));
1594: return;
1595: }
1596:
1597: i = 0;
1598: result = mysql_use_result(sql);
1599: if (result) {
1600: while((row = mysql_fetch_row(result)))
1601: {
1602: if (sqlRpmAnalyzeResourceRow(row) != NULL)
1603: i++;
1604: }
1605: mysql_free_result(result);
1606: }
1607: if(mysql_errno(sql)) {
1608: fprintf(stderr, "sqlInitSqlResourceList Error: %s\n", mysql_error(sql));
1609: return;
1610: }
1611:
1612:
1613: if (rpm2htmlVerbose)
1614: printf("sqlInitSqlResourceList done: %d entries\n", i);
1615: sqlResourceListInitialized++;
1616: return;
1617: }
1.36 veillard 1618:
1619: char *
1620: sqlRpmAnalyzeDistributionRow(MYSQL_ROW row) {
1621: const char *id;
1622: const char *name;
1623: char **tmp;
1624: int distribution;
1625:
1626: if (row == NULL)
1627: return(NULL);
1628: id = row[0];
1629: name = row[1];
1630: if ((id == NULL) || (name == NULL))
1631: return(NULL);
1632:
1633: if (sscanf(id, "%d", &distribution) != 1)
1634: return(NULL);
1635: if ((distribution <= 0) || (distribution > 100000)) {
1636: fprintf(stderr, "Dist number out of range %d\n", distribution);
1637: return(NULL);
1638: }
1639: if (distribution >= sqlDistributionListLen) {
1640: int i = sqlDistributionListLen;
1641: sqlDistributionListLen = distribution + 100;
1642: tmp = (char **) debugRealloc(sqlDistributionList,
1643: (sqlDistributionListLen) * sizeof(char *));
1644: if (sqlDistributionList == NULL) {
1645: fprintf(stderr, "sqlInitSqlDistributionList Error: out of memory\n");
1646: return(NULL);
1647: }
1648: sqlDistributionList = tmp;
1649: memset(&sqlDistributionList[i], 0, sizeof(char *) * (sqlDistributionListLen - i));
1650: }
1651:
1652: sqlDistributionList[distribution] = debugStrdup(name);
1653: return(sqlDistributionList[distribution]);
1654: }
1655:
1656: void
1657: sqlInitSqlDistributionList(void) {
1658: MYSQL_RES *result;
1659: MYSQL_ROW row;
1660: char *query;
1661: int i;
1662:
1663: if (sqlDistributionListInitialized != 0)
1664: return;
1665:
1666: if (rpm2htmlVerbose)
1667: printf("sqlInitSqlDistributionList query\n");
1668:
1669: /*
1670: * Allocate the array
1671: */
1672: sqlDistributionListLen = 100;
1673: sqlDistributionList = (char **) debugMalloc((sqlDistributionListLen) * sizeof(char *));
1674: if (sqlDistributionList == NULL) {
1675: fprintf(stderr, "sqlInitSqlDistributionList Error: out of memory\n");
1676: return;
1677: }
1.40 veillard 1678: memset(sqlDistributionList, 0, (sqlDistributionListLen) * sizeof(char *));
1679:
1.36 veillard 1680: /*
1681: * query the database for the values
1682: */
1683: query = "select ID,Name from Distributions";
1684:
1685: if (mysql_query(sql,query)) {
1686: printf("sqlInitSqlDistributionList: SELECT from Distributions failed: %s\n",
1687: mysql_error(sql));
1688: return;
1689: }
1690:
1691: i = 0;
1692: result = mysql_use_result(sql);
1693: if (result) {
1694: while((row = mysql_fetch_row(result)))
1695: {
1696: if (sqlRpmAnalyzeDistributionRow(row) != NULL)
1697: i++;
1698: }
1699: mysql_free_result(result);
1700: }
1701: if(mysql_errno(sql)) {
1702: fprintf(stderr, "sqlInitSqlDistributionList Error: %s\n", mysql_error(sql));
1703: return;
1704: }
1705:
1706:
1707: if (rpm2htmlVerbose)
1708: printf("sqlInitSqlDistributionList done: %d entries\n", i);
1709: sqlDistributionListInitialized++;
1710: return;
1711: }
1712:
1.35 veillard 1713:
1714: char *
1715: sqlRpmAnalyzeVendorRow(MYSQL_ROW row) {
1716: const char *id;
1717: const char *name;
1718: char **tmp;
1719: int vendor;
1720:
1721: if (row == NULL)
1722: return(NULL);
1723: id = row[0];
1724: name = row[1];
1725: if ((id == NULL) || (name == NULL))
1726: return(NULL);
1727:
1728: if (sscanf(id, "%d", &vendor) != 1)
1729: return(NULL);
1730: if ((vendor <= 0) || (vendor > 100000)) {
1731: fprintf(stderr, "Dist number out of range %d\n", vendor);
1732: return(NULL);
1733: }
1734: if (vendor >= sqlVendorListLen) {
1735: int i = sqlVendorListLen;
1736: sqlVendorListLen = vendor + 100;
1737: tmp = (char **) debugRealloc(sqlVendorList,
1738: (sqlVendorListLen) * sizeof(char *));
1739: if (sqlVendorList == NULL) {
1740: fprintf(stderr, "sqlInitSqlVendorList Error: out of memory\n");
1741: return(NULL);
1742: }
1743: sqlVendorList = tmp;
1744: memset(&sqlVendorList[i], 0, sizeof(char *) * (sqlVendorListLen - i));
1745: }
1746:
1747: sqlVendorList[vendor] = debugStrdup(name);
1748: return(sqlVendorList[vendor]);
1749: }
1750:
1751: void
1752: sqlInitSqlVendorList(void) {
1753: MYSQL_RES *result;
1754: MYSQL_ROW row;
1755: char *query;
1756: int i;
1757:
1758: if (sqlVendorListInitialized != 0)
1759: return;
1760:
1761: if (rpm2htmlVerbose)
1762: printf("sqlInitSqlVendorList query\n");
1763:
1764: /*
1765: * Allocate the array
1766: */
1767: sqlVendorListLen = 100;
1768: sqlVendorList = (char **) debugMalloc((sqlVendorListLen) * sizeof(char *));
1769: if (sqlVendorList == NULL) {
1770: fprintf(stderr, "sqlInitSqlVendorList Error: out of memory\n");
1771: return;
1772: }
1773:
1774: /*
1775: * query the database for the values
1776: */
1777: query = "select ID,Name from Vendors";
1778:
1779: if (mysql_query(sql,query)) {
1.36 veillard 1780: printf("sqlInitSqlVendorList: SELECT from Vendors failed: %s\n",
1.35 veillard 1781: mysql_error(sql));
1782: return;
1783: }
1784:
1785: i = 0;
1786: result = mysql_use_result(sql);
1787: if (result) {
1788: while((row = mysql_fetch_row(result)))
1789: {
1790: if (sqlRpmAnalyzeVendorRow(row) != NULL)
1791: i++;
1792: }
1793: mysql_free_result(result);
1794: }
1795: if(mysql_errno(sql)) {
1796: fprintf(stderr, "sqlInitSqlVendorList Error: %s\n", mysql_error(sql));
1797: return;
1798: }
1799:
1800:
1801: if (rpm2htmlVerbose)
1802: printf("sqlInitSqlVendorList done: %d entries\n", i);
1803: sqlVendorListInitialized++;
1804: return;
1805: }
1.26 veillard 1806:
1807: rpmDirPtr
1808: sqlRpmAnalyzeDirRow(MYSQL_ROW row) {
1809: rpmDirPtr ret;
1810: const char *id;
1811: const char *name;
1812: const char *vendor;
1813: const char *directory;
1814: const char *path;
1815: const char *url;
1816: const char *urlSrc;
1817: const char *html;
1818: const char *color;
1819: int dist;
1820:
1821: if (row == NULL)
1822: return(NULL);
1823: id = row[0];
1824: name = row[1];
1825: vendor = row[2];
1826: directory = row[3];
1827: path = row[4];
1828: url = row[5];
1829: urlSrc = row[6];
1830: html = row[7];
1831: color = row[8];
1832: if ((id == NULL) || (name == NULL) ||
1833: (directory == NULL) || (path == NULL) || (url == NULL))
1834: return(NULL);
1835:
1836: if (sscanf(id, "%d", &dist) != 1)
1837: return(NULL);
1838: if ((dist <= 0) || (dist > SQL_MAX_DISTRIBS)) {
1839: fprintf(stderr, "Dist number out of range %d\n", dist);
1840: return(NULL);
1841: }
1842:
1843:
1844: ret = (rpmDirPtr) debugMalloc(sizeof(rpmDir));
1845: if (ret == NULL)
1846: return(NULL);
1847: memset(ret, 0, sizeof(rpmDir));
1848: /* Generic stuff */
1.28 daniel 1849: if (rpm2html_dir != NULL)
1.26 veillard 1850: ret->dir = debugStrdup(rpm2html_dir);
1.28 daniel 1851: if (rpm2html_host != NULL)
1.26 veillard 1852: ret->host = debugStrdup(rpm2html_host);
1.28 daniel 1853: if (rpm2html_maint != NULL)
1.26 veillard 1854: ret->maint = debugStrdup(rpm2html_maint);
1.28 daniel 1855: if (rpm2html_mail != NULL)
1.26 veillard 1856: ret->mail = debugStrdup(rpm2html_mail);
1.28 daniel 1857: if (rpm2html_url != NULL)
1.26 veillard 1858: ret->url = debugStrdup(rpm2html_url);
1859: /* specific stuff */
1860: ret->no = dist;
1861: ret->rpmdir = debugStrdup(directory);
1862: ret->subdir = debugStrdup(path);
1863: ret->name = debugStrdup(name);
1864: ret->ftp = debugStrdup(url);
1865: if (color != NULL)
1866: ret->color = debugStrdup(color);
1.28 daniel 1867: else
1868: ret->color = debugStrdup("#ffffff");
1.26 veillard 1869: if (urlSrc != NULL)
1870: ret->ftpsrc = debugStrdup(urlSrc);
1871: return(ret);
1872: }
1873:
1874: void
1875: sqlInitSqlDirList(void) {
1.28 daniel 1876: char host[200];
1.26 veillard 1877: rpmDirPtr cur;
1878: MYSQL_RES *result;
1879: MYSQL_ROW row;
1880: char *query;
1881: int i;
1882:
1883: if (sqlDirListInitialized != 0)
1884: return;
1885:
1.28 daniel 1886: gethostname(host, sizeof(host));
1887: currentTime = time(NULL);
1888: rpm2html_rpm2html_thishost = &host[0];
1889: readConfigSql();
1890: if (rpm2html_host == NULL) {
1891: rpm2html_host = strdup(rpm2html_rpm2html_thishost);
1892: }
1.26 veillard 1893: for (i = 0; i < SQL_MAX_DISTRIBS;i++)
1894: sqlDirList[i] = NULL;
1895:
1896: if (rpm2htmlVerbose)
1897: printf("sqlInitSqlDirList query\n");
1898:
1.29 veillard 1899: query = "select ID,Name,Vendor,Directory,Path,URL,URLSrc,Html,Color from Distribs";
1.26 veillard 1900:
1901: if (mysql_query(sql,query)) {
1902: printf("sqlInitSqlDirList: SELECT from Packages failed: %s\n",
1903: mysql_error(sql));
1904: return;
1905: }
1906:
1907: i = 0;
1908: result = mysql_use_result(sql);
1909: if (result) {
1910: while((row = mysql_fetch_row(result)))
1911: {
1912: cur = sqlRpmAnalyzeDirRow(row);
1913: if (cur != NULL) {
1914: sqlDirList[cur->no] = cur;
1915: i++;
1916: }
1917: }
1918: mysql_free_result(result);
1919: }
1920: if(mysql_errno(sql)) {
1921: fprintf(stderr, "sqlInitSqlDirList Error: %s\n", mysql_error(sql));
1922: return;
1923: }
1924:
1925: if (rpm2htmlVerbose)
1926: printf("sqlInitSqlDirList done: %d entries\n", i);
1927: sqlDirListInitialized++;
1928: return;
1929: }
1930:
1931: rpmDataPtr
1932: sqlRpmAnalyzeRow(MYSQL_ROW row) {
1933: rpmDataPtr ret;
1934: const char *id;
1935: const char *name;
1936: const char *version;
1937: const char *release;
1938: const char *arch;
1939: const char *date;
1940: const char *summary;
1941: const char *filename;
1942: const char *distrib;
1.30 daniel 1943: const char *group;
1.33 veillard 1944: const char *os;
1.35 veillard 1945: const char *packager;
1.36 veillard 1946: const char *vendor;
1.26 veillard 1947: int dist;
1948:
1949: if (row == NULL)
1950: return(NULL);
1951: id = row[0];
1952: name = row[1];
1953: version = row[2];
1954: release = row[3];
1955: arch = row[4];
1956: date = row[5];
1957: summary = row[6];
1958: filename = row[7];
1959: distrib = row[8];
1.30 daniel 1960: group = row[9];
1.33 veillard 1961: os = row[10];
1.35 veillard 1962: packager = row[11];
1.36 veillard 1963: vendor = row[12];
1.26 veillard 1964: if ((id == NULL) || (name == NULL) || (version == NULL) ||
1965: (release == NULL) || (arch == NULL) || (date == NULL) ||
1966: (summary == NULL) || (filename == NULL) || (distrib == NULL))
1967: return(NULL);
1968:
1969: ret = (rpmDataPtr) debugMalloc(sizeof(rpmData));
1970: if (ret == NULL)
1971: return(NULL);
1972: memset(ret, 0, sizeof(rpmData));
1973: ret->name = debugStrdup(name);
1974: ret->version = debugStrdup(version);
1975: ret->release = debugStrdup(release);
1976: ret->arch = debugStrdup(arch);
1977: ret->summary = debugStrdup(summary);
1978: ret->name = debugStrdup(name);
1979: ret->filename = debugStrdup(filename);
1.33 veillard 1980: if (os == NULL)
1981: ret->os = debugStrdup("Linux");
1982: else
1983: ret->os = debugStrdup(os);
1.30 daniel 1984: if (group != NULL)
1985: ret->group = debugStrdup(group);
1.26 veillard 1986: sscanf(date, "%d", (int *) &(ret->date));
1.35 veillard 1987: if (packager != NULL) {
1988: int tmp = 0;
1989: sscanf(packager, "%d", (int *) &tmp);
1990: if ((tmp > 0) && (tmp < sqlVendorListLen)) {
1991: if (sqlVendorList[tmp] != NULL)
1992: ret->vendor = debugStrdup(sqlVendorList[tmp]);
1993: }
1994: }
1.36 veillard 1995: if (vendor != NULL) {
1996: int tmp = 0;
1997: sscanf(vendor, "%d", (int *) &tmp);
1998: if ((tmp > 0) && (tmp < sqlDistributionListLen)) {
1999: if (sqlVendorList[tmp] != NULL)
2000: ret->distribution = debugStrdup(sqlDistributionList[tmp]);
2001: }
2002: }
1.35 veillard 2003: if (ret->vendor == NULL)
2004: ret->vendor = debugStrdup("Unknown");
2005: if (ret->distribution == NULL)
2006: ret->distribution = debugStrdup("Unknown");
1.26 veillard 2007: sscanf(distrib, "%d", &dist);
2008: ret->dir = sqlDirList[dist];
1.28 daniel 2009: if ((ret->dir != NULL) && (ret->dir->rpmdir != NULL)) {
2010: int len = strlen(ret->dir->rpmdir);
2011: if (!strncmp(ret->filename, ret->dir->rpmdir, len)) {
2012: char *start, *end;
2013: start = &(ret->filename[len]);
2014: while (*start == '/') start++;
2015: end = &start[strlen(start) - 1];
2016: while ((end >= start) && (*end != '/')) end--;
2017: if (end > start) {
2018: char *tmp;
2019: tmp = debugMalloc((end - start) + 1);
2020: if (tmp != NULL) {
2021: strncpy(tmp, start, end - start);
2022: tmp[end - start] = 0;
2023: ret->subdir = tmp;
2024: }
2025: }
2026: }
2027: }
1.26 veillard 2028: return(ret);
2029: }
2030:
2031: rpmDataPtr
2032: sqlRpmByDate(void) {
2033: rpmDataPtr list = NULL;
2034: rpmDataPtr cur, last = NULL;
2035: MYSQL_RES *result;
2036: MYSQL_ROW row;
2037: char *query;
2038:
2039: sqlInitSqlDirList();
1.35 veillard 2040: sqlInitSqlVendorList();
1.36 veillard 2041: sqlInitSqlDistributionList();
1.26 veillard 2042: if (rpm2htmlVerbose)
2043: printf("sqlRpmByDate query\n");
2044:
1.35 veillard 2045: query = "select ID,Name,Version,Release,Arch,Date,Summary,filename,Dist,Category,Os,Packager,Vendor from Packages where Date IS NOT NULL and Date < UNIX_TIMESTAMP() + 300000 order by Date desc limit 1000";
1.26 veillard 2046:
2047: /*
2048: * Search first for the ID if it already exists
2049: */
2050: if (mysql_query(sql,query)) {
2051: printf("sqlRpmByDate: SELECT from Packages failed: %s\n",
2052: mysql_error(sql));
2053: return(NULL);
2054: }
2055:
2056: result = mysql_use_result(sql);
2057: if (result) {
2058: while((row = mysql_fetch_row(result)))
2059: {
2060: cur = sqlRpmAnalyzeRow(row);
2061: if (cur != NULL) {
2062: if (last == NULL)
2063: list = cur;
2064: else
2065: last->next = cur;
2066: last = cur;
2067: }
2068: }
2069: mysql_free_result(result);
2070: }
2071: if(mysql_errno(sql)) {
2072: fprintf(stderr, "sqlRpmByDate Error: %s\n", mysql_error(sql));
2073: return(NULL);
2074: }
2075:
2076: if (rpm2htmlVerbose)
2077: printf("sqlRpmByDate done\n");
2078: return(list);
2079: }
2080:
1.29 veillard 2081: rpmDataPtr
2082: sqlRpmAll(void) {
2083: rpmDataPtr list = NULL;
2084: rpmDataPtr cur, last = NULL;
2085: MYSQL_RES *result;
2086: MYSQL_ROW row;
2087: char *query;
2088:
2089: sqlInitSqlDirList();
1.35 veillard 2090: sqlInitSqlVendorList();
1.36 veillard 2091: sqlInitSqlDistributionList();
1.29 veillard 2092: if (rpm2htmlVerbose)
2093: printf("sqlRpmAll query\n");
2094:
1.35 veillard 2095: query = "select ID,Name,Version,Release,Arch,Date,Summary,filename,Dist,Category,Os,Packager,Vendor from Packages";
1.29 veillard 2096:
2097: /*
2098: * Search first for the ID if it already exists
2099: */
2100: if (mysql_query(sql,query)) {
2101: printf("sqlRpmByDate: SELECT from Packages failed: %s\n",
2102: mysql_error(sql));
2103: return(NULL);
2104: }
2105:
2106: result = mysql_use_result(sql);
2107: if (result) {
2108: while((row = mysql_fetch_row(result)))
2109: {
2110: cur = sqlRpmAnalyzeRow(row);
2111: if (cur != NULL) {
2112: if (last == NULL)
2113: list = cur;
2114: else
2115: last->next = cur;
2116: last = cur;
1.32 daniel 2117:
2118: rpmAddSoftware(cur);
1.29 veillard 2119: }
2120: }
2121: mysql_free_result(result);
2122: }
2123: if(mysql_errno(sql)) {
2124: fprintf(stderr, "sqlRpmByDate Error: %s\n", mysql_error(sql));
2125: return(NULL);
2126: }
2127:
2128: if (rpm2htmlVerbose)
2129: printf("sqlRpmAll done\n");
2130: return(list);
2131: }
2132:
1.26 veillard 2133: /************************************************************************
1.8 veillard 2134: * *
1.6 veillard 2135: * Export functions *
2136: * *
2137: ************************************************************************/
2138:
1.41 ! veillard 2139: void sql_dump_rdf(const char *resource) {
! 2140: MYSQL_RES *result;
! 2141: MYSQL_ROW row;
! 2142: char query[SMALL_QUERY];
! 2143: FILE *rdf;
! 2144: char *filename;
! 2145: char *dist;
! 2146: char *name;
! 2147: char *version;
! 2148: char *release;
! 2149: char *arch;
! 2150: char *os;
! 2151: char *packager;
! 2152: char *date;
! 2153: char *size;
! 2154: char *subdir;
! 2155: int distrib;
! 2156:
! 2157: if (resource == NULL)
! 2158: return;
! 2159: if (!rpm2html_dump_rdf_resources)
! 2160: return;
! 2161: if ((rpm2html_host == NULL) || (rpm2html_url == NULL))
! 2162: return;
! 2163:
! 2164: snprintf(query, SMALL_QUERY,
! 2165: "select filename,Dist,Name,Version,Release,Arch,Os,Packager,Date,Size from Packages where Name=\"%s\"",
! 2166: resource);
! 2167: query[SMALL_QUERY - 1] = 0;
! 2168: if (mysql_query(sql, query)) {
! 2169: printf("sql_dump_rdf: SELECT from Packages failed: %s\n",
! 2170: mysql_error(sql));
! 2171: return;
! 2172: }
! 2173: result = mysql_use_result(sql);
! 2174: if (result == NULL) {
! 2175: printf("sql_dump_rdf: SELECT from Packages failed: %s\n",
! 2176: mysql_error(sql));
! 2177: return;
! 2178: }
! 2179: while((row = mysql_fetch_row(result))) {
! 2180: filename = row[0];
! 2181: dist = row[1];
! 2182: name = row[2];
! 2183: version = row[3];
! 2184: release = row[4];
! 2185: arch = row[5];
! 2186: os = row[6];
! 2187: packager = row[7];
! 2188: date = row[8];
! 2189: size = row[9];
! 2190: if ((filename == NULL) || (dist == NULL) || (name == NULL) ||
! 2191: (version == NULL) || (release == NULL) || (arch == NULL) ||
! 2192: (os == NULL) || (packager == NULL) || (date == NULL) ||
! 2193: (size == NULL)) {
! 2194: continue;
! 2195: }
! 2196: if (sscanf(dist, "%d", &distrib) != 1)
! 2197: continue;
! 2198: if ((distrib < 1) || (distrib >= SQL_MAX_DISTRIBS) ||
! 2199: (sqlDirList[distrib] == NULL))
! 2200: continue;
! 2201:
! 2202: subdir = sqlDirList[distrib]->subdir;
! 2203: /*************
! 2204: int len = strlen(ret->dir->rpmdir);
! 2205: if (!strncmp(ret->filename, ret->dir->rpmdir, len)) {
! 2206: char *start, *end;
! 2207: start = &(ret->filename[len]);
! 2208: while (*start == '/') start++;
! 2209: end = &start[strlen(start) - 1];
! 2210: while ((end >= start) && (*end != '/')) end--;
! 2211: if (end > start) {
! 2212: char *tmp;
! 2213: tmp = debugMalloc((end - start) + 1);
! 2214: if (tmp != NULL) {
! 2215: strncpy(tmp, start, end - start);
! 2216: tmp[end - start] = 0;
! 2217: ret->subdir = tmp;
! 2218: }
! 2219: }
! 2220: }
! 2221: ******************/
! 2222: }
! 2223: }
! 2224:
1.6 veillard 2225: void sql_show_config(void) {
2226: MYSQL_RES *result;
2227: MYSQL_ROW row;
1.8 veillard 2228: int id, i;
2229: int index = 0;
2230: int ids[500];
2231: char query[SMALL_QUERY];
1.6 veillard 2232:
2233:
1.8 veillard 2234: printf(";\n; Configuration file for rpm2html\n");
2235: printf("; http://rpmfind.net/linux/rpm2html/\n;\n\n");
2236: mysql_query(sql,"SELECT Name,Value FROM Config");
1.6 veillard 2237: result = mysql_use_result(sql);
2238:
2239: while((row = mysql_fetch_row(result)))
2240: {
1.8 veillard 2241: if (row[0] == NULL) {
2242: printf("\n");
2243: } else {
2244: if (!strcmp(row[0], "maint"))
2245: printf("; maintainer of the local rpm mirror\n");
2246: else if (!strcmp(row[0], "mail"))
2247: printf("; mail for the maintainer\n");
2248: else if (!strcmp(row[0], "dir"))
2249: printf("; Directory to store the HTML pages produced\n");
2250: else if (!strcmp(row[0], "url"))
2251: printf("; The relative URL for front pages\n");
2252: else if (!strcmp(row[0], "header"))
2253: printf("; Extra link in the navigation bar\n");
2254: else if (!strcmp(row[0], "html"))
2255: printf("; Export the local packages in HTML format\n");
2256: else if (!strcmp(row[0], "tree"))
2257: printf("; Build the tree for the distributions\n");
2258: else if (!strcmp(row[0], "rdf"))
2259: printf("; Export the local packages in RDF format\n");
2260: else if (!strcmp(row[0], "rdf_dir"))
2261: printf("; Directory to store the RDf tree\n");
2262: else if (!strcmp(row[0], "rdf_resources"))
2263: printf("; Compile a list of resources in RDF format\n");
2264: else if (!strcmp(row[0], "rdf_resources_dir"))
2265: printf("; Directory to store the RDf resources tree\n");
2266:
1.6 veillard 2267: if (row[1] == NULL)
1.8 veillard 2268: printf("%s\n\n", row[0]);
1.6 veillard 2269: else
1.8 veillard 2270: printf("%s=%s\n\n", row[0], row[1]);
2271: }
2272: }
2273: mysql_free_result(result);
2274: if(mysql_errno(sql)) {
2275: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2276: }
2277:
2278: /*
2279: * Dump the Metadata
2280: */
2281: printf(";\n; The metadata mirrors list\n;\n\n[metadata]\n");
2282: mysql_query(sql,"SELECT URL FROM Metadata");
2283: result = mysql_use_result(sql);
2284:
2285: while((row = mysql_fetch_row(result)))
2286: {
2287: if (row[0] != NULL) {
2288: printf("mirror=%s\n", row[0]);
1.6 veillard 2289: }
2290: }
1.8 veillard 2291: mysql_free_result(result);
1.6 veillard 2292: if(mysql_errno(sql)) {
2293: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2294: }
2295:
1.8 veillard 2296: /*
2297: * Dump the distributions informations
2298: * 1/ collect the list of IDs for the distribs
2299: */
2300: printf("\n\n;\n; The distribution list\n;\n\n");
2301: mysql_query(sql,"SELECT ID FROM Distribs");
2302: result = mysql_use_result(sql);
2303:
2304: while((row = mysql_fetch_row(result)))
2305: {
2306: if (row[0] != NULL) {
2307: if (sscanf(row[0], "%d", &id) == 1) {
2308: ids[index++] = id;
2309: }
2310: }
2311: }
2312: mysql_free_result(result);
2313:
2314: /*
2315: * Dump each distribution separately.
2316: */
2317: for (i = 0;i < index;i++) {
2318:
2319: snprintf(query, SMALL_QUERY - 1,
1.10 veillard 2320: "SELECT Directory,Name,Vendor,Path,URL,URLSrc,Description,Html,Color \
1.8 veillard 2321: FROM Distribs WHERE ID=%d", ids[i]);
2322: query[SMALL_QUERY - 1] = 0;
2323: if (mysql_query(sql,query)) {
2324: printf("sql_show_config: SELECT Distrib %d failed: %s\n",
2325: ids[i], mysql_error(sql));
2326: continue;
2327: }
2328:
2329: result = mysql_use_result(sql);
2330: if (result) {
2331: while((row = mysql_fetch_row(result)))
2332: {
2333: if (row[0] == NULL)
2334: break;
2335: printf("[%s]\n", row[0]);
2336: if (row[1] != NULL)
2337: printf("name=%s\n", row[1]);
2338: if (row[3] != NULL)
2339: printf("subdir=%s\n", row[3]);
2340: if (row[4] != NULL)
2341: printf("ftp=%s\n", row[4]);
2342: if (row[5] != NULL)
2343: printf("ftpsrc=%s\n", row[5]);
1.10 veillard 2344: if (row[7] != NULL)
2345: printf("html=%s\n", row[7]);
2346: if (row[8] != NULL)
2347: printf("color=%s\n", row[8]);
1.8 veillard 2348: }
2349: }
2350: mysql_free_result(result);
1.12 veillard 2351:
2352: /*
2353: * Extract the mirrors for this distribution.
2354: */
2355: snprintf(query, SMALL_QUERY - 1,
2356: "SELECT URL FROM Mirrors WHERE ID=%d", ids[i]);
2357: query[SMALL_QUERY - 1] = 0;
2358: if (mysql_query(sql,query)) {
2359: printf("sql_show_config: SELECT Mirrors %d failed: %s\n",
2360: ids[i], mysql_error(sql));
2361: printf("\n\n");
2362: continue;
2363: }
2364: result = mysql_use_result(sql);
2365: if (result) {
2366: while((row = mysql_fetch_row(result)))
2367: {
2368: if (row[0] == NULL)
2369: continue;
2370: printf("mirror=%s\n", row[0]);
2371: }
2372: }
2373: mysql_free_result(result);
2374:
1.8 veillard 2375: printf("\n\n");
2376: }
2377:
2378: printf(";\n; End of the configuration file for rpm2html\n;\n");
1.6 veillard 2379: }
2380:
2381: void sql_show_metadata(void) {
2382: MYSQL_RES *result;
2383: MYSQL_ROW row;
2384:
2385:
2386: mysql_query(sql,"SELECT URL FROM Metadata");
2387: result = mysql_use_result(sql);
2388:
2389: while((row = mysql_fetch_row(result)))
2390: {
2391: if (row[0] == NULL)
2392: printf("NULL !\n");
2393: else {
2394: printf("%s\n", row[0]);
2395: }
2396: }
2397: if(mysql_errno(sql)) {
2398: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2399: }
2400:
2401: }
2402:
2403: void sql_show_mirrors(void) {
2404: MYSQL_RES *result;
2405: MYSQL_ROW row;
2406:
2407:
2408: mysql_query(sql,"SELECT URL FROM Mirrors");
2409: result = mysql_use_result(sql);
2410:
2411: while((row = mysql_fetch_row(result)))
2412: {
2413: if (row[0] == NULL)
2414: printf("NULL !\n");
2415: else {
2416: printf("%s\n", row[0]);
2417: }
2418: }
2419: if(mysql_errno(sql)) {
2420: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2421: }
2422: }
2423:
1.5 veillard 2424: void sql_show_vendors(void) {
1.1 veillard 2425: MYSQL_RES *result;
2426: MYSQL_ROW row;
2427:
2428:
2429: mysql_query(sql,"SELECT Name, URL FROM Vendors");
2430: result = mysql_use_result(sql);
2431:
2432: while((row = mysql_fetch_row(result)))
2433: {
2434: if (row[0] == NULL)
2435: printf("NULL !\n");
2436: else {
2437: if (row[1] == NULL)
2438: printf("%s : no url\n", row[0]);
2439: else
2440: printf("%s : %s\n", row[0], row[1]);
2441: }
2442: }
2443: if(mysql_errno(sql)) {
2444: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2445: }
2446:
2447: }
2448:
1.5 veillard 2449: void sql_show_distribs(void) {
1.1 veillard 2450: MYSQL_RES *result;
2451: MYSQL_ROW row;
2452:
2453:
2454: mysql_query(sql,"SELECT Name, Path, URL FROM Distribs");
2455: result = mysql_use_result(sql);
2456:
2457: while((row = mysql_fetch_row(result)))
2458: {
2459: if (row[0] == NULL)
2460: printf("NULL !\n");
2461: else {
2462: if (row[1] == NULL)
2463: printf("%s : no Path\n", row[0]);
2464: else {
2465: if (row[2] == NULL)
2466: printf("%s : %s : no url\n", row[0], row[1]);
2467: else
2468: printf("%s : %s : %s\n", row[0], row[1], row[2]);
2469: }
2470: }
2471: }
2472: if(mysql_errno(sql)) {
2473: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2474: }
2475:
2476: }
2477:
1.5 veillard 2478: int sql_show_table_stats(const char *table, const char *key) {
1.6 veillard 2479: char query[MAX_QUERY];
1.2 veillard 2480: MYSQL_RES *result;
2481: MYSQL_ROW row;
2482: int res;
2483:
2484: /*
2485: * Search first for the ID if it already exists
2486: */
1.6 veillard 2487: snprintf(query, MAX_QUERY - 1, "SELECT COUNT(%s) FROM %s", key, table);
2488: query[MAX_QUERY - 1] = 0;
1.2 veillard 2489: if (mysql_query(sql,query)) {
1.5 veillard 2490: printf("sql_show_table_stats: SELECT COUNT failed: %s\n",
1.2 veillard 2491: mysql_error(sql));
2492: return(-1);
2493: }
2494:
2495: result = mysql_use_result(sql);
2496: if (result) {
2497: while((row = mysql_fetch_row(result)))
2498: {
2499: /*
2500: * Lookup the value and return it
2501: */
2502: if (row[0] == NULL) {
2503: mysql_free_result(result);
1.5 veillard 2504: printf("sql_show_table_stats: select count returns NULL !\n");
1.2 veillard 2505: return(-1);
2506: }
2507: if (sscanf(row[0], "%d", &res) != 1) {
2508: mysql_free_result(result);
1.5 veillard 2509: printf("sql_show_table_stats: value non numeric %s\n", row[0]);
1.2 veillard 2510: return(-1);
2511: }
2512: mysql_free_result(result);
2513: if (res <= 0)
2514: printf(" %s is empty\n", table);
2515: else
2516: printf(" %s contains %d records\n", table, res);
2517: return(res);
2518: }
2519: mysql_free_result(result);
2520: }
2521: if(mysql_errno(sql)) {
1.5 veillard 2522: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.2 veillard 2523: }
2524: return(-1);
2525: }
2526:
1.5 veillard 2527: int sql_show_stats(void) {
1.2 veillard 2528: const char *query = "SHOW TABLES";
2529: MYSQL_RES *result;
2530: MYSQL_ROW row;
2531:
2532: int tables = 0;
2533: int records = 0;
2534:
2535: if (mysql_query(sql,query)) {
2536: printf("sql_check_tables: SHOW TABLES failed %s\n",
2537: mysql_error(sql));
2538: return(-1);
2539: }
2540:
2541: result = mysql_use_result(sql);
2542: if (result) {
2543: while((row = mysql_fetch_row(result)))
2544: {
2545: if (row[0] == NULL) {
2546: mysql_free_result(result);
2547: printf("sql_check_tables: SHOW TABLES returns NULL !\n");
2548: return(-1);
2549: }
2550: tables++;
2551: }
2552: mysql_free_result(result);
2553: }
2554: if(mysql_errno(sql)) {
1.5 veillard 2555: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.2 veillard 2556: }
2557: printf("%d tables in use\n", tables);
1.5 veillard 2558: records += sql_show_table_stats("Config", "Name");
2559: records += sql_show_table_stats("Distribs", "Name");
2560: records += sql_show_table_stats("Vendors", "Name");
2561: records += sql_show_table_stats("Mirrors", "URL");
2562: records += sql_show_table_stats("Metadata", "URL");
2563: records += sql_show_table_stats("Packages", "Name");
1.8 veillard 2564: records += sql_show_table_stats("Requires", "Resource");
2565: records += sql_show_table_stats("Provides", "Resource");
1.5 veillard 2566: records += sql_show_table_stats("Files", "Path");
1.2 veillard 2567: printf("Total: %d records\n", records);
2568: return(records);
2569: }
2570:
1.26 veillard 2571: void sql_show_latests(void) {
2572: rpmDataPtr list;
2573:
2574: list = sqlRpmByDate();
2575: if (list == NULL) {
2576: fprintf(stderr, "no package in database\n");
2577: return;
2578: }
1.28 daniel 2579: dumpRpmByDate(list, 0);
1.29 veillard 2580: }
2581:
1.40 veillard 2582:
2583: void sql_show_resources(void) {
2584: int i;
2585:
2586: sqlInitSqlDirList();
2587: sqlInitSqlResourceList();
2588: for (i = 0;i < sqlResourceListLen;i++) {
2589: if (sqlResourceList[i] == NULL)
2590: break;
2591: dumpRessRedirHtml(sqlResourceList[i]);
1.41 ! veillard 2592: if (rpm2html_dump_rdf_resources)
! 2593: sql_dump_rdf(sqlResourceList[i]);
1.40 veillard 2594: }
2595: fprintf(stderr, "Dumped %d redirrect resource pages\n", i);
2596: }
2597:
1.29 veillard 2598: void sql_show_all(void) {
2599: rpmDataPtr list;
1.31 veillard 2600: #ifdef SQL_DEBUG_TIMING
2601: time_t cur, last;
1.29 veillard 2602:
1.31 veillard 2603: last = time(NULL);
2604: #endif
1.29 veillard 2605: list = sqlRpmAll();
2606: if (list == NULL) {
2607: fprintf(stderr, "no package in database\n");
2608: return;
2609: }
1.31 veillard 2610: #ifdef SQL_DEBUG_TIMING
2611: cur = time(NULL);
2612: fprintf(stderr, "sqlRpmAll took %d seconds\n", (int)(cur - last));
2613: last = cur;
2614: #endif
2615:
2616: rpmNameSort(&list, 0);
2617: dumpRpmByName(rpmSoftwareList, 0);
2618:
2619: #ifdef SQL_DEBUG_TIMING
2620: cur = time(NULL);
2621: fprintf(stderr, "dumpRpmByName took %d seconds\n", (int)(cur - last));
2622: last = cur;
2623: #endif
2624:
2625: rpmGroupSort(&list, 0);
1.32 daniel 2626: dumpRpmByGroups(rpmSoftwareList, 0);
1.31 veillard 2627:
2628: #ifdef SQL_DEBUG_TIMING
2629: cur = time(NULL);
2630: fprintf(stderr, "dumpRpmByGroups took %d seconds\n", (int)(cur - last));
2631: last = cur;
2632: #endif
1.35 veillard 2633:
2634: rpmVendorSort(&list, 0);
2635: dumpRpmByVendors(list, 0);
2636:
2637: #ifdef SQL_DEBUG_TIMING
2638: cur = time(NULL);
2639: fprintf(stderr, "dumpRpmByVendors took %d seconds\n", (int)(cur - last));
1.36 veillard 2640: last = cur;
2641: #endif
2642:
2643: rpmDistribSort(&list, 0);
2644: dumpRpmByDistribs(list, 0);
2645:
2646: #ifdef SQL_DEBUG_TIMING
2647: cur = time(NULL);
2648: fprintf(stderr, "dumpRpmByDistribs took %d seconds\n", (int)(cur - last));
1.35 veillard 2649: last = cur;
2650: #endif
2651:
1.39 daniel 2652: rpmDateSort(&list, 0);
1.37 veillard 2653: dumpRpmByDate(list, 0);
2654:
2655: #ifdef SQL_DEBUG_TIMING
2656: cur = time(NULL);
2657: fprintf(stderr, "dumpRpmByDate took %d seconds\n", (int)(cur - last));
2658: last = cur;
2659: #endif
2660:
1.40 veillard 2661: rpmdataCleanup();
2662: sleep(30);
1.26 veillard 2663: }
2664:
1.2 veillard 2665: /************************************************************************
2666: * *
2667: * rpm2html configuration functions *
2668: * *
2669: ************************************************************************/
2670:
2671: int readConfigSql(void) {
1.6 veillard 2672: char query[MAX_QUERY];
1.3 veillard 2673: MYSQL_RES *result;
2674: MYSQL_ROW row;
1.4 veillard 2675: int dir = 0;
1.3 veillard 2676:
1.2 veillard 2677: /*
1.3 veillard 2678: * General configuration informations
1.2 veillard 2679: */
1.6 veillard 2680: snprintf(query, MAX_QUERY - 1, "SELECT Name,Value FROM Config");
2681: query[MAX_QUERY - 1] = 0;
1.3 veillard 2682: if (mysql_query(sql,query)) {
2683: printf("sql_check_tables: SELECT Config failed %s\n",
2684: mysql_error(sql));
2685: return(-1);
2686: }
2687:
2688: result = mysql_use_result(sql);
2689: if (result) {
2690: while((row = mysql_fetch_row(result)))
2691: {
2692: if ((row[0] == NULL) || (row[1] == NULL)) {
2693: fprintf(stderr, "readConfigSql : found NULL value\n");
2694: continue;
2695: }
1.4 veillard 2696: if (!strcmp(row[0], "dir"))
2697: dir = 1;
1.3 veillard 2698: addConfigEntry(RPM2HTML_NAME, row[0], row[1]);
2699: }
2700: mysql_free_result(result);
2701: }
2702: if(mysql_errno(sql)) {
1.5 veillard 2703: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.4 veillard 2704: }
2705: if (dir == 0) {
2706: fprintf(stderr, "readConfigSql : no directory\n");
2707: return(-1);
1.3 veillard 2708: }
2709:
2710: /*
2711: * The metadata mirror list.
2712: */
1.6 veillard 2713: snprintf(query, MAX_QUERY - 1, "SELECT URL FROM Metadata");
2714: query[MAX_QUERY - 1] = 0;
1.3 veillard 2715: if (mysql_query(sql,query)) {
2716: printf("sql_check_tables: SELECT Metadata failed %s\n",
2717: mysql_error(sql));
2718: return(-1);
2719: }
2720:
2721: result = mysql_use_result(sql);
2722: if (result) {
2723: while((row = mysql_fetch_row(result)))
2724: {
2725: if (row[0] == NULL) {
2726: fprintf(stderr, "readConfigSql : found NULL metadata\n");
2727: continue;
2728: }
2729: addConfigEntry("metadata", "mirror", row[0]);
2730: }
2731: mysql_free_result(result);
2732: }
2733: if(mysql_errno(sql)) {
1.5 veillard 2734: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 2735: }
2736:
2737: /*
2738: * The distribution lists
2739: */
1.6 veillard 2740: snprintf(query, MAX_QUERY - 1, "SELECT Directory,Name,URL,URLSrc,Path FROM Distribs");
2741: query[MAX_QUERY - 1] = 0;
1.3 veillard 2742: if (mysql_query(sql,query)) {
2743: printf("sql_check_tables: SELECT Distribs failed %s\n",
2744: mysql_error(sql));
2745: return(-1);
2746: }
2747:
2748: result = mysql_use_result(sql);
2749: if (result) {
2750: while((row = mysql_fetch_row(result)))
2751: {
2752: if (row[0] == NULL) {
2753: fprintf(stderr, "readConfigSql : found NULL distro\n");
2754: continue;
2755: }
2756:
2757: if (row[1] != NULL)
2758: addConfigEntry(row[0], "name", row[1]);
2759: if (row[2] != NULL)
2760: addConfigEntry(row[0], "ftp", row[2]);
2761: if (row[3] != NULL)
2762: addConfigEntry(row[0], "ftp", row[3]);
2763: if (row[4] != NULL)
2764: addConfigEntry(row[0], "subdir", row[4]);
2765: }
2766: mysql_free_result(result);
2767: }
2768: if(mysql_errno(sql)) {
1.5 veillard 2769: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 2770: }
2771:
2772: /*
2773: * The Mirrors
2774: */
1.6 veillard 2775: snprintf(query, MAX_QUERY - 1, "SELECT Distribs.Directory,Mirrors.URL FROM Distribs,Mirrors WHERE Distribs.ID = Mirrors.ID");
2776: query[MAX_QUERY - 1] = 0;
1.3 veillard 2777: if (mysql_query(sql,query)) {
2778: printf("sql_check_tables: SELECT Distribs failed %s\n",
2779: mysql_error(sql));
2780: return(-1);
2781: }
2782:
2783: result = mysql_use_result(sql);
2784: if (result) {
2785: while((row = mysql_fetch_row(result)))
2786: {
2787: if ((row[0] == NULL) || (row[1] == NULL)) {
2788: fprintf(stderr, "readConfigSql : found NULL mirror\n");
2789: continue;
2790: }
2791:
2792: addConfigEntry(row[0], "mirror", row[1]);
2793: }
2794: mysql_free_result(result);
2795: }
2796: if(mysql_errno(sql)) {
1.5 veillard 2797: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 2798: }
2799:
1.5 veillard 2800: /*
2801: * TODO: add the language(s) stuff
2802: */
1.3 veillard 2803: return(0);
1.2 veillard 2804: }
2805:
2806: void sqlConfigEntry(const char *rpmdir, const char *name, const char *value) {
2807: int distrib;
2808:
2809: if (rpm2htmlVerbose > 1)
2810: printf("sqlConfigEntry(\"%s\", \"%s\", \"%s\")\n", rpmdir, name, value);
2811:
2812: /*
2813: * case of global option for rpm2html.
2814: */
2815: if (!strcasecmp(rpmdir, RPM2HTML_NAME)) {
1.5 veillard 2816: sql_add_config_info(name, value);
1.2 veillard 2817: return;
2818: }
2819:
2820: /*
2821: * Options for the metadata mirrors.
2822: */
2823: if (!strcasecmp(rpmdir, "metadata")) {
2824: if (!strcasecmp(name, "mirror")) {
1.5 veillard 2825: sql_add_metadata_base(value);
1.2 veillard 2826: } else {
2827: printf("Config file : %s entry for [metadata] ignored\n", name);
2828: }
2829: return;
2830: }
2831:
2832: /*
2833: * option for a directory.
2834: */
2835: if (!strcasecmp(name, "name")) {
1.9 veillard 2836: sql_add_distrib(value, NULL, rpmdir, NULL, NULL, NULL, NULL,
2837: NULL, NULL);
1.2 veillard 2838: } else if (!strcasecmp(name, "subdir")) {
2839: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2840: if (distrib > 0)
2841: sql_update_id("Distribs", distrib, "Path", value);
2842: } else if (!strcasecmp(name, "url")) {
2843: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2844: if (distrib > 0)
2845: sql_update_id("Distribs", distrib, "URL", value);
2846: } else if (!strcasecmp(name, "ftp")) {
2847: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2848: if (distrib > 0)
2849: sql_update_id("Distribs", distrib, "URL", value);
2850: } else if (!strcasecmp(name, "ftpsrc")) {
2851: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2852: if (distrib > 0)
2853: sql_update_id("Distribs", distrib, "URLSrc", value);
1.9 veillard 2854: } else if (!strcasecmp(name, "html")) {
2855: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2856: if (distrib > 0)
2857: sql_update_id("Distribs", distrib, "Html", value);
2858: } else if (!strcasecmp(name, "color")) {
2859: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2860: if (distrib > 0)
2861: sql_update_id("Distribs", distrib, "Color", value);
1.2 veillard 2862: } else if (!strcasecmp(name, "mirror")) {
2863: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2864: if (distrib > 0)
1.5 veillard 2865: sql_add_dist_mirror(distrib, value, 0);
1.2 veillard 2866: } else {
2867: printf("Config file : %s entry for [%s] ignored\n", name, rpmdir);
2868: }
2869: }
1.1 veillard 2870:
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sql.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / rpm2html