Annotation of rpm2html/sql.c, revision 1.44
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.43 veillard 1203: const char *Os, const char *Distribution, const char *Vendor) {
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:
1.42 veillard 1446: /*
1447: * Remove the RDF and HTML files.
1448: * TODO
1449: */
1.8 veillard 1450: return(-1);
1451: }
1452:
1453: int sql_check_packages(void) {
1454: MYSQL_RES *result;
1455: MYSQL_ROW row;
1.20 daniel 1456: char *query = "SELECT filename,ID FROM Packages";
1.8 veillard 1457: struct stat buf;
1458: int id;
1.22 daniel 1459: int ids[2500]; /* Do not remove more than 2500 package per run */
1.8 veillard 1460: int index;
1461: int total = 0;
1462:
1463: if (rpm2htmlVerbose)
1464: printf("Database cleanup\n");
1.42 veillard 1465: sqlInitSqlDistributionList();
1.8 veillard 1466: index = 0;
1467: /*
1468: * Search first for the ID if it already exists
1469: */
1470: if (mysql_query(sql,query)) {
1471: printf("sql_check_packages: SELECT from Packages failed: %s\n",
1472: mysql_error(sql));
1473: return(-1);
1474: }
1475:
1476: result = mysql_use_result(sql);
1477: if (result) {
1478: while((row = mysql_fetch_row(result)))
1479: {
1480: if ((row[0] == NULL) || (row[1] == NULL)) {
1481: printf("sql_check_packages: Path or ID is NULL !\n");
1482: continue;
1483: }
1.35 veillard 1484: if (!strncmp(row[0], "localbase", 9))
1485: continue;
1486:
1.8 veillard 1487: if ((stat(row[0], &buf) < 0) || (buf.st_size < 50)) {
1488: /*
1489: * Need to remove the package from the database.
1490: */
1491: if (sscanf(row[1], "%d", &id) != 1) {
1492: printf("sql_check_packages: ID non numeric %s\n", row[1]);
1493: continue;
1494: }
1495: ids[index++] = id;
1.20 daniel 1496: if (rpm2htmlVerbose)
1.8 veillard 1497: printf("Removing %s ID %d\n", row[0], id);
1.22 daniel 1498: if (index >= 2500)
1.8 veillard 1499: break;
1500: }
1501: }
1502: mysql_free_result(result);
1503: }
1504: if(mysql_errno(sql)) {
1505: fprintf(stderr, "sql_update Error: %s\n", mysql_error(sql));
1506: return(-1);
1507: }
1508:
1509: /*
1510: * Do the cleanup.
1511: */
1.20 daniel 1512: if (rpm2htmlVerbose)
1513: printf("Database cleanup : removing %d entries...\n", index);
1.8 veillard 1514: for (id = 0;id < index;id++) {
1515: sql_remove_package(ids[id]);
1516: }
1517:
1.34 veillard 1518: printf("Database cleanup : removed %d entries\n", index);
1.8 veillard 1519: return(total);
1520: }
1521:
1522: /************************************************************************
1.26 veillard 1523: * *
1524: * Package lists extraction *
1525: * *
1526: ************************************************************************/
1527: int sqlDirListInitialized = 0;
1528: rpmDirPtr sqlDirList[SQL_MAX_DISTRIBS];
1.35 veillard 1529: int sqlVendorListInitialized = 0;
1530: int sqlVendorListLen;
1531: char **sqlVendorList;
1.36 veillard 1532: int sqlDistributionListInitialized = 0;
1533: int sqlDistributionListLen;
1534: char **sqlDistributionList;
1.40 veillard 1535: int sqlResourceListInitialized = 0;
1536: int sqlResourceListLen = 0;
1537: int sqlResourceListMax = 0;
1538: char **sqlResourceList;
1539:
1540: char *
1541: sqlRpmAnalyzeResourceRow(MYSQL_ROW row) {
1542: const char *name;
1543: char **tmp, *ret;
1544:
1545: if (row == NULL)
1546: return(NULL);
1547: name = row[0];
1548: if (name == NULL)
1549: return(NULL);
1550:
1551: if (sqlResourceListLen >= sqlResourceListMax) {
1552: sqlResourceListMax *= 2;
1553: tmp = (char **) debugRealloc(sqlResourceList,
1554: (sqlResourceListMax) * sizeof(char *));
1555: if (sqlResourceList == NULL) {
1556: fprintf(stderr, "sqlInitSqlResourceList Error: out of memory\n");
1557: return(NULL);
1558: }
1559: sqlResourceList = tmp;
1560: }
1561:
1562: ret = sqlResourceList[sqlResourceListLen++] = debugStrdup(name);
1563: return(ret);
1564: }
1565:
1566: void
1567: sqlInitSqlResourceList(void) {
1568: MYSQL_RES *result;
1569: MYSQL_ROW row;
1570: char *query;
1571: int i;
1572:
1573: if (sqlResourceListInitialized != 0)
1574: return;
1575:
1576: if (rpm2htmlVerbose)
1577: printf("sqlInitSqlResourceList query\n");
1578:
1579: /*
1580: * Allocate the array
1581: */
1582: sqlResourceListLen = 0;
1583: sqlResourceListMax = 1000;
1584: sqlResourceList = (char **) debugMalloc((sqlResourceListMax) *
1585: sizeof(char *));
1586: if (sqlResourceList == NULL) {
1587: fprintf(stderr, "sqlInitSqlResourceList Error: out of memory\n");
1588: return;
1589: }
1590:
1591: /*
1592: * query the database for the values
1593: */
1594: query = "select Resource from Provides group by Resource";
1595:
1596: if (mysql_query(sql,query)) {
1597: printf("sqlInitSqlResourceList: SELECT from Provides failed: %s\n",
1598: mysql_error(sql));
1599: return;
1600: }
1601:
1602: i = 0;
1603: result = mysql_use_result(sql);
1604: if (result) {
1605: while((row = mysql_fetch_row(result)))
1606: {
1607: if (sqlRpmAnalyzeResourceRow(row) != NULL)
1608: i++;
1609: }
1610: mysql_free_result(result);
1611: }
1612: if(mysql_errno(sql)) {
1613: fprintf(stderr, "sqlInitSqlResourceList Error: %s\n", mysql_error(sql));
1614: return;
1615: }
1616:
1617:
1618: if (rpm2htmlVerbose)
1619: printf("sqlInitSqlResourceList done: %d entries\n", i);
1620: sqlResourceListInitialized++;
1621: return;
1622: }
1.36 veillard 1623:
1624: char *
1625: sqlRpmAnalyzeDistributionRow(MYSQL_ROW row) {
1626: const char *id;
1627: const char *name;
1628: char **tmp;
1629: int distribution;
1630:
1631: if (row == NULL)
1632: return(NULL);
1633: id = row[0];
1634: name = row[1];
1635: if ((id == NULL) || (name == NULL))
1636: return(NULL);
1637:
1638: if (sscanf(id, "%d", &distribution) != 1)
1639: return(NULL);
1640: if ((distribution <= 0) || (distribution > 100000)) {
1641: fprintf(stderr, "Dist number out of range %d\n", distribution);
1642: return(NULL);
1643: }
1644: if (distribution >= sqlDistributionListLen) {
1645: int i = sqlDistributionListLen;
1646: sqlDistributionListLen = distribution + 100;
1647: tmp = (char **) debugRealloc(sqlDistributionList,
1648: (sqlDistributionListLen) * sizeof(char *));
1649: if (sqlDistributionList == NULL) {
1650: fprintf(stderr, "sqlInitSqlDistributionList Error: out of memory\n");
1651: return(NULL);
1652: }
1653: sqlDistributionList = tmp;
1654: memset(&sqlDistributionList[i], 0, sizeof(char *) * (sqlDistributionListLen - i));
1655: }
1656:
1657: sqlDistributionList[distribution] = debugStrdup(name);
1658: return(sqlDistributionList[distribution]);
1659: }
1660:
1661: void
1662: sqlInitSqlDistributionList(void) {
1663: MYSQL_RES *result;
1664: MYSQL_ROW row;
1665: char *query;
1666: int i;
1667:
1668: if (sqlDistributionListInitialized != 0)
1669: return;
1670:
1671: if (rpm2htmlVerbose)
1672: printf("sqlInitSqlDistributionList query\n");
1673:
1674: /*
1675: * Allocate the array
1676: */
1677: sqlDistributionListLen = 100;
1678: sqlDistributionList = (char **) debugMalloc((sqlDistributionListLen) * sizeof(char *));
1679: if (sqlDistributionList == NULL) {
1680: fprintf(stderr, "sqlInitSqlDistributionList Error: out of memory\n");
1681: return;
1682: }
1.40 veillard 1683: memset(sqlDistributionList, 0, (sqlDistributionListLen) * sizeof(char *));
1684:
1.36 veillard 1685: /*
1686: * query the database for the values
1687: */
1688: query = "select ID,Name from Distributions";
1689:
1690: if (mysql_query(sql,query)) {
1691: printf("sqlInitSqlDistributionList: SELECT from Distributions failed: %s\n",
1692: mysql_error(sql));
1693: return;
1694: }
1695:
1696: i = 0;
1697: result = mysql_use_result(sql);
1698: if (result) {
1699: while((row = mysql_fetch_row(result)))
1700: {
1701: if (sqlRpmAnalyzeDistributionRow(row) != NULL)
1702: i++;
1703: }
1704: mysql_free_result(result);
1705: }
1706: if(mysql_errno(sql)) {
1707: fprintf(stderr, "sqlInitSqlDistributionList Error: %s\n", mysql_error(sql));
1708: return;
1709: }
1710:
1711:
1712: if (rpm2htmlVerbose)
1713: printf("sqlInitSqlDistributionList done: %d entries\n", i);
1714: sqlDistributionListInitialized++;
1715: return;
1716: }
1717:
1.35 veillard 1718:
1719: char *
1720: sqlRpmAnalyzeVendorRow(MYSQL_ROW row) {
1721: const char *id;
1722: const char *name;
1723: char **tmp;
1724: int vendor;
1725:
1726: if (row == NULL)
1727: return(NULL);
1728: id = row[0];
1729: name = row[1];
1730: if ((id == NULL) || (name == NULL))
1731: return(NULL);
1732:
1733: if (sscanf(id, "%d", &vendor) != 1)
1734: return(NULL);
1735: if ((vendor <= 0) || (vendor > 100000)) {
1736: fprintf(stderr, "Dist number out of range %d\n", vendor);
1737: return(NULL);
1738: }
1739: if (vendor >= sqlVendorListLen) {
1740: int i = sqlVendorListLen;
1741: sqlVendorListLen = vendor + 100;
1742: tmp = (char **) debugRealloc(sqlVendorList,
1743: (sqlVendorListLen) * sizeof(char *));
1744: if (sqlVendorList == NULL) {
1745: fprintf(stderr, "sqlInitSqlVendorList Error: out of memory\n");
1746: return(NULL);
1747: }
1748: sqlVendorList = tmp;
1749: memset(&sqlVendorList[i], 0, sizeof(char *) * (sqlVendorListLen - i));
1750: }
1751:
1752: sqlVendorList[vendor] = debugStrdup(name);
1753: return(sqlVendorList[vendor]);
1754: }
1755:
1756: void
1757: sqlInitSqlVendorList(void) {
1758: MYSQL_RES *result;
1759: MYSQL_ROW row;
1760: char *query;
1761: int i;
1762:
1763: if (sqlVendorListInitialized != 0)
1764: return;
1765:
1766: if (rpm2htmlVerbose)
1767: printf("sqlInitSqlVendorList query\n");
1768:
1769: /*
1770: * Allocate the array
1771: */
1772: sqlVendorListLen = 100;
1773: sqlVendorList = (char **) debugMalloc((sqlVendorListLen) * sizeof(char *));
1774: if (sqlVendorList == NULL) {
1775: fprintf(stderr, "sqlInitSqlVendorList Error: out of memory\n");
1776: return;
1777: }
1778:
1779: /*
1780: * query the database for the values
1781: */
1782: query = "select ID,Name from Vendors";
1783:
1784: if (mysql_query(sql,query)) {
1.36 veillard 1785: printf("sqlInitSqlVendorList: SELECT from Vendors failed: %s\n",
1.35 veillard 1786: mysql_error(sql));
1787: return;
1788: }
1789:
1790: i = 0;
1791: result = mysql_use_result(sql);
1792: if (result) {
1793: while((row = mysql_fetch_row(result)))
1794: {
1795: if (sqlRpmAnalyzeVendorRow(row) != NULL)
1796: i++;
1797: }
1798: mysql_free_result(result);
1799: }
1800: if(mysql_errno(sql)) {
1801: fprintf(stderr, "sqlInitSqlVendorList Error: %s\n", mysql_error(sql));
1802: return;
1803: }
1804:
1805:
1806: if (rpm2htmlVerbose)
1807: printf("sqlInitSqlVendorList done: %d entries\n", i);
1808: sqlVendorListInitialized++;
1809: return;
1810: }
1.26 veillard 1811:
1812: rpmDirPtr
1813: sqlRpmAnalyzeDirRow(MYSQL_ROW row) {
1814: rpmDirPtr ret;
1815: const char *id;
1816: const char *name;
1817: const char *vendor;
1818: const char *directory;
1819: const char *path;
1820: const char *url;
1821: const char *urlSrc;
1822: const char *html;
1823: const char *color;
1824: int dist;
1825:
1826: if (row == NULL)
1827: return(NULL);
1828: id = row[0];
1829: name = row[1];
1830: vendor = row[2];
1831: directory = row[3];
1832: path = row[4];
1833: url = row[5];
1834: urlSrc = row[6];
1835: html = row[7];
1836: color = row[8];
1837: if ((id == NULL) || (name == NULL) ||
1838: (directory == NULL) || (path == NULL) || (url == NULL))
1839: return(NULL);
1840:
1841: if (sscanf(id, "%d", &dist) != 1)
1842: return(NULL);
1843: if ((dist <= 0) || (dist > SQL_MAX_DISTRIBS)) {
1844: fprintf(stderr, "Dist number out of range %d\n", dist);
1845: return(NULL);
1846: }
1847:
1848:
1849: ret = (rpmDirPtr) debugMalloc(sizeof(rpmDir));
1850: if (ret == NULL)
1851: return(NULL);
1852: memset(ret, 0, sizeof(rpmDir));
1853: /* Generic stuff */
1.28 daniel 1854: if (rpm2html_dir != NULL)
1.26 veillard 1855: ret->dir = debugStrdup(rpm2html_dir);
1.28 daniel 1856: if (rpm2html_host != NULL)
1.26 veillard 1857: ret->host = debugStrdup(rpm2html_host);
1.28 daniel 1858: if (rpm2html_maint != NULL)
1.26 veillard 1859: ret->maint = debugStrdup(rpm2html_maint);
1.28 daniel 1860: if (rpm2html_mail != NULL)
1.26 veillard 1861: ret->mail = debugStrdup(rpm2html_mail);
1.28 daniel 1862: if (rpm2html_url != NULL)
1.26 veillard 1863: ret->url = debugStrdup(rpm2html_url);
1864: /* specific stuff */
1865: ret->no = dist;
1866: ret->rpmdir = debugStrdup(directory);
1867: ret->subdir = debugStrdup(path);
1868: ret->name = debugStrdup(name);
1869: ret->ftp = debugStrdup(url);
1870: if (color != NULL)
1871: ret->color = debugStrdup(color);
1.28 daniel 1872: else
1873: ret->color = debugStrdup("#ffffff");
1.26 veillard 1874: if (urlSrc != NULL)
1875: ret->ftpsrc = debugStrdup(urlSrc);
1876: return(ret);
1877: }
1878:
1879: void
1880: sqlInitSqlDirList(void) {
1.28 daniel 1881: char host[200];
1.26 veillard 1882: rpmDirPtr cur;
1883: MYSQL_RES *result;
1884: MYSQL_ROW row;
1885: char *query;
1886: int i;
1887:
1888: if (sqlDirListInitialized != 0)
1889: return;
1890:
1.28 daniel 1891: gethostname(host, sizeof(host));
1892: currentTime = time(NULL);
1893: rpm2html_rpm2html_thishost = &host[0];
1894: readConfigSql();
1895: if (rpm2html_host == NULL) {
1896: rpm2html_host = strdup(rpm2html_rpm2html_thishost);
1897: }
1.26 veillard 1898: for (i = 0; i < SQL_MAX_DISTRIBS;i++)
1899: sqlDirList[i] = NULL;
1900:
1901: if (rpm2htmlVerbose)
1902: printf("sqlInitSqlDirList query\n");
1903:
1.29 veillard 1904: query = "select ID,Name,Vendor,Directory,Path,URL,URLSrc,Html,Color from Distribs";
1.26 veillard 1905:
1906: if (mysql_query(sql,query)) {
1907: printf("sqlInitSqlDirList: SELECT from Packages failed: %s\n",
1908: mysql_error(sql));
1909: return;
1910: }
1911:
1912: i = 0;
1913: result = mysql_use_result(sql);
1914: if (result) {
1915: while((row = mysql_fetch_row(result)))
1916: {
1917: cur = sqlRpmAnalyzeDirRow(row);
1918: if (cur != NULL) {
1919: sqlDirList[cur->no] = cur;
1920: i++;
1921: }
1922: }
1923: mysql_free_result(result);
1924: }
1925: if(mysql_errno(sql)) {
1926: fprintf(stderr, "sqlInitSqlDirList Error: %s\n", mysql_error(sql));
1927: return;
1928: }
1929:
1930: if (rpm2htmlVerbose)
1931: printf("sqlInitSqlDirList done: %d entries\n", i);
1932: sqlDirListInitialized++;
1933: return;
1934: }
1935:
1936: rpmDataPtr
1937: sqlRpmAnalyzeRow(MYSQL_ROW row) {
1938: rpmDataPtr ret;
1939: const char *id;
1940: const char *name;
1941: const char *version;
1942: const char *release;
1943: const char *arch;
1944: const char *date;
1945: const char *summary;
1946: const char *filename;
1947: const char *distrib;
1.30 daniel 1948: const char *group;
1.33 veillard 1949: const char *os;
1.35 veillard 1950: const char *packager;
1.36 veillard 1951: const char *vendor;
1.26 veillard 1952: int dist;
1953:
1954: if (row == NULL)
1955: return(NULL);
1956: id = row[0];
1957: name = row[1];
1958: version = row[2];
1959: release = row[3];
1960: arch = row[4];
1961: date = row[5];
1962: summary = row[6];
1963: filename = row[7];
1964: distrib = row[8];
1.30 daniel 1965: group = row[9];
1.33 veillard 1966: os = row[10];
1.35 veillard 1967: packager = row[11];
1.36 veillard 1968: vendor = row[12];
1.26 veillard 1969: if ((id == NULL) || (name == NULL) || (version == NULL) ||
1970: (release == NULL) || (arch == NULL) || (date == NULL) ||
1971: (summary == NULL) || (filename == NULL) || (distrib == NULL))
1972: return(NULL);
1973:
1974: ret = (rpmDataPtr) debugMalloc(sizeof(rpmData));
1975: if (ret == NULL)
1976: return(NULL);
1977: memset(ret, 0, sizeof(rpmData));
1978: ret->name = debugStrdup(name);
1979: ret->version = debugStrdup(version);
1980: ret->release = debugStrdup(release);
1981: ret->arch = debugStrdup(arch);
1982: ret->summary = debugStrdup(summary);
1983: ret->name = debugStrdup(name);
1984: ret->filename = debugStrdup(filename);
1.33 veillard 1985: if (os == NULL)
1986: ret->os = debugStrdup("Linux");
1987: else
1988: ret->os = debugStrdup(os);
1.30 daniel 1989: if (group != NULL)
1990: ret->group = debugStrdup(group);
1.26 veillard 1991: sscanf(date, "%d", (int *) &(ret->date));
1.35 veillard 1992: if (packager != NULL) {
1993: int tmp = 0;
1994: sscanf(packager, "%d", (int *) &tmp);
1995: if ((tmp > 0) && (tmp < sqlVendorListLen)) {
1996: if (sqlVendorList[tmp] != NULL)
1997: ret->vendor = debugStrdup(sqlVendorList[tmp]);
1998: }
1999: }
1.36 veillard 2000: if (vendor != NULL) {
2001: int tmp = 0;
2002: sscanf(vendor, "%d", (int *) &tmp);
2003: if ((tmp > 0) && (tmp < sqlDistributionListLen)) {
2004: if (sqlVendorList[tmp] != NULL)
2005: ret->distribution = debugStrdup(sqlDistributionList[tmp]);
2006: }
2007: }
1.35 veillard 2008: if (ret->vendor == NULL)
2009: ret->vendor = debugStrdup("Unknown");
2010: if (ret->distribution == NULL)
2011: ret->distribution = debugStrdup("Unknown");
1.26 veillard 2012: sscanf(distrib, "%d", &dist);
2013: ret->dir = sqlDirList[dist];
1.28 daniel 2014: if ((ret->dir != NULL) && (ret->dir->rpmdir != NULL)) {
2015: int len = strlen(ret->dir->rpmdir);
2016: if (!strncmp(ret->filename, ret->dir->rpmdir, len)) {
2017: char *start, *end;
2018: start = &(ret->filename[len]);
2019: while (*start == '/') start++;
2020: end = &start[strlen(start) - 1];
2021: while ((end >= start) && (*end != '/')) end--;
2022: if (end > start) {
2023: char *tmp;
2024: tmp = debugMalloc((end - start) + 1);
2025: if (tmp != NULL) {
2026: strncpy(tmp, start, end - start);
2027: tmp[end - start] = 0;
2028: ret->subdir = tmp;
2029: }
2030: }
2031: }
2032: }
1.26 veillard 2033: return(ret);
2034: }
2035:
2036: rpmDataPtr
2037: sqlRpmByDate(void) {
2038: rpmDataPtr list = NULL;
2039: rpmDataPtr cur, last = NULL;
2040: MYSQL_RES *result;
2041: MYSQL_ROW row;
2042: char *query;
2043:
2044: sqlInitSqlDirList();
1.35 veillard 2045: sqlInitSqlVendorList();
1.36 veillard 2046: sqlInitSqlDistributionList();
1.26 veillard 2047: if (rpm2htmlVerbose)
2048: printf("sqlRpmByDate query\n");
2049:
1.35 veillard 2050: 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 2051:
2052: /*
2053: * Search first for the ID if it already exists
2054: */
2055: if (mysql_query(sql,query)) {
2056: printf("sqlRpmByDate: SELECT from Packages failed: %s\n",
2057: mysql_error(sql));
2058: return(NULL);
2059: }
2060:
2061: result = mysql_use_result(sql);
2062: if (result) {
2063: while((row = mysql_fetch_row(result)))
2064: {
2065: cur = sqlRpmAnalyzeRow(row);
2066: if (cur != NULL) {
2067: if (last == NULL)
2068: list = cur;
2069: else
2070: last->next = cur;
2071: last = cur;
2072: }
2073: }
2074: mysql_free_result(result);
2075: }
2076: if(mysql_errno(sql)) {
2077: fprintf(stderr, "sqlRpmByDate Error: %s\n", mysql_error(sql));
2078: return(NULL);
2079: }
2080:
2081: if (rpm2htmlVerbose)
2082: printf("sqlRpmByDate done\n");
2083: return(list);
2084: }
2085:
1.29 veillard 2086: rpmDataPtr
2087: sqlRpmAll(void) {
2088: rpmDataPtr list = NULL;
2089: rpmDataPtr cur, last = NULL;
2090: MYSQL_RES *result;
2091: MYSQL_ROW row;
2092: char *query;
2093:
2094: sqlInitSqlDirList();
1.35 veillard 2095: sqlInitSqlVendorList();
1.36 veillard 2096: sqlInitSqlDistributionList();
1.29 veillard 2097: if (rpm2htmlVerbose)
2098: printf("sqlRpmAll query\n");
2099:
1.35 veillard 2100: query = "select ID,Name,Version,Release,Arch,Date,Summary,filename,Dist,Category,Os,Packager,Vendor from Packages";
1.29 veillard 2101:
2102: /*
2103: * Search first for the ID if it already exists
2104: */
2105: if (mysql_query(sql,query)) {
2106: printf("sqlRpmByDate: SELECT from Packages failed: %s\n",
2107: mysql_error(sql));
2108: return(NULL);
2109: }
2110:
2111: result = mysql_use_result(sql);
2112: if (result) {
2113: while((row = mysql_fetch_row(result)))
2114: {
2115: cur = sqlRpmAnalyzeRow(row);
2116: if (cur != NULL) {
2117: if (last == NULL)
2118: list = cur;
2119: else
2120: last->next = cur;
2121: last = cur;
1.32 daniel 2122:
2123: rpmAddSoftware(cur);
1.29 veillard 2124: }
2125: }
2126: mysql_free_result(result);
2127: }
2128: if(mysql_errno(sql)) {
2129: fprintf(stderr, "sqlRpmByDate Error: %s\n", mysql_error(sql));
2130: return(NULL);
2131: }
2132:
2133: if (rpm2htmlVerbose)
2134: printf("sqlRpmAll done\n");
2135: return(list);
2136: }
2137:
1.26 veillard 2138: /************************************************************************
1.8 veillard 2139: * *
1.6 veillard 2140: * Export functions *
2141: * *
2142: ************************************************************************/
2143:
1.41 veillard 2144: void sql_dump_rdf(const char *resource) {
2145: MYSQL_RES *result;
2146: MYSQL_ROW row;
2147: char query[SMALL_QUERY];
2148: FILE *rdf;
2149: char *filename;
2150: char *dist;
2151: char *name;
2152: char *version;
2153: char *release;
2154: char *arch;
2155: char *os;
2156: char *packager;
2157: char *date;
2158: char *size;
1.44 ! daniel 2159: char *vendorstr;
1.41 veillard 2160: char *subdir;
1.42 veillard 2161: char *psubdir;
2162: char *rpmdir;
2163: char *start, *end;
1.41 veillard 2164: int distrib;
1.42 veillard 2165: int vendor;
1.44 ! daniel 2166: int person;
1.42 veillard 2167: int len;
2168: char path[500];
1.41 veillard 2169:
2170: if (resource == NULL)
2171: return;
1.44 ! daniel 2172: if (resource[0] == '/')
! 2173: return;
1.41 veillard 2174: if (!rpm2html_dump_rdf_resources)
2175: return;
1.42 veillard 2176: if (!rpm2html_rdf_resources_dir)
2177: return;
1.41 veillard 2178: if ((rpm2html_host == NULL) || (rpm2html_url == NULL))
2179: return;
2180:
1.42 veillard 2181: /*
2182: * Open the RDF resource descritpion.
2183: */
2184: mkdir(rpm2html_rdf_resources_dir, 0755);
2185: snprintf(path, 500, "%s/%s.rdf",
2186: rpm2html_rdf_resources_dir, resource);
2187: path[499] = 0;
2188: rdf = fopen(path, "w");
2189: if (rdf == NULL) {
2190: fprintf(stderr, "unable to write to %s\n", path);
2191: return;
2192: }
2193: fprintf(rdf, "<?xml version=\"1.0\"?>\n");
2194: fprintf(rdf, "<rdf:RDF xmlns:RDF=\"http://www.w3.org/TR/WD-rdf-syntax#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:RPM=\"http://www.rpm.org/\">\n");
2195:
2196: /*
2197: * Query the database for the informations providing the resource.
2198: */
1.41 veillard 2199: snprintf(query, SMALL_QUERY,
1.44 ! daniel 2200: "select filename,Dist,Name,Version,Release,Arch,Os,Packager,Date,Size,Vendor from Packages where Name=\"%s\"",
1.41 veillard 2201: resource);
2202: query[SMALL_QUERY - 1] = 0;
2203: if (mysql_query(sql, query)) {
2204: printf("sql_dump_rdf: SELECT from Packages failed: %s\n",
2205: mysql_error(sql));
1.42 veillard 2206: fprintf(rdf, "</rdf:RDF>\n");
2207: fclose(rdf);
1.41 veillard 2208: return;
2209: }
2210: result = mysql_use_result(sql);
2211: if (result == NULL) {
2212: printf("sql_dump_rdf: SELECT from Packages failed: %s\n",
2213: mysql_error(sql));
1.42 veillard 2214: fprintf(rdf, "</rdf:RDF>\n");
2215: fclose(rdf);
1.41 veillard 2216: return;
2217: }
2218: while((row = mysql_fetch_row(result))) {
2219: filename = row[0];
2220: dist = row[1];
2221: name = row[2];
2222: version = row[3];
2223: release = row[4];
2224: arch = row[5];
2225: os = row[6];
2226: packager = row[7];
2227: date = row[8];
2228: size = row[9];
1.44 ! daniel 2229: vendorstr = row[10];
1.41 veillard 2230: if ((filename == NULL) || (dist == NULL) || (name == NULL) ||
2231: (version == NULL) || (release == NULL) || (arch == NULL) ||
1.44 ! daniel 2232: (os == NULL) || (date == NULL) || (vendorstr == NULL) ||
1.41 veillard 2233: (size == NULL)) {
2234: continue;
2235: }
1.42 veillard 2236: if (!strncmp(filename, "localbase", 9))
2237: continue;
1.41 veillard 2238: if (sscanf(dist, "%d", &distrib) != 1)
2239: continue;
1.44 ! daniel 2240: if ((distrib < 1) || (distrib >= SQL_MAX_DISTRIBS) ||
! 2241: (sqlDirList[distrib] == NULL))
1.42 veillard 2242: continue;
1.44 ! daniel 2243: if (vendorstr != NULL) {
! 2244: if (sscanf(vendorstr, "%d", &vendor) != 1)
1.42 veillard 2245: continue;
2246: }
2247: if ((vendor < 1) || (vendor >= sqlDistributionListLen) ||
2248: (sqlDistributionList[vendor] == NULL))
1.41 veillard 2249: continue;
1.44 ! daniel 2250: if (packager != NULL) {
! 2251: if (sscanf(packager, "%d", &person) != 1)
! 2252: continue;
! 2253: }
! 2254: if ((person < 1) || (person >= sqlVendorListLen) ||
! 2255: (sqlVendorList[person] == NULL))
! 2256: continue;
1.41 veillard 2257:
2258: subdir = sqlDirList[distrib]->subdir;
1.42 veillard 2259: rpmdir = sqlDirList[distrib]->rpmdir;
2260: len = strlen(rpmdir);
2261: if (strncmp(filename, rpmdir, len)) {
2262: fprintf(stderr, "%s out of subdir %s\n", filename, subdir);
2263: continue;
2264: }
2265: start = &(filename[len]);
2266: while (*start == '/') start++;
2267: end = &start[strlen(start) - 1];
2268: while ((end >= start) && (*end != '/')) end--;
2269: if (end <= start) {
2270: psubdir = debugStrdup("");
2271: } else {
2272: psubdir = debugMalloc((end - start) + 1);
2273: if (psubdir == NULL) {
2274: fprintf(stderr, "Out of memory\n");
2275: continue;
1.41 veillard 2276: }
1.42 veillard 2277: strncpy(psubdir, start, end - start);
2278: psubdir[end - start] = 0;
1.41 veillard 2279: }
1.42 veillard 2280: fprintf(rdf, " <rdf:Description about=\"%s/%s/%s-%s-%s.%s.rpm\" ",
2281: sqlDirList[distrib]->ftp,psubdir,name,version,release,arch);
2282: fprintf(rdf, "href=\"../%s/%s/%s-%s-%s.%s.rdf\">\n",
2283: subdir,psubdir,name,version,release,arch);
2284: fprintf(rdf, " <RPM:Name>%s</RPM:Name>\n", name);
2285: fprintf(rdf, " <RPM:Version>%s</RPM:Version>\n", version);
2286: fprintf(rdf, " <RPM:Release>%s</RPM:Release>\n", release);
2287: fprintf(rdf, " <RPM:Arch>%s</RPM:Arch>\n", arch);
2288: fprintf(rdf, " <RPM:Os>%s</RPM:Os>\n", os);
2289: if (packager == NULL)
2290: fprintf(rdf, " <RPM:Distribution>Unknown</RPM:Distribution>\n");
2291: else
2292: fprintf(rdf, " <RPM:Distribution>%s</RPM:Distribution>\n",
2293: sqlDistributionList[vendor]);
2294: fprintf(rdf, " <RPM:Vendor>%s</RPM:Vendor>\n",
1.44 ! daniel 2295: sqlVendorList[person]);
1.42 veillard 2296: fprintf(rdf, " <RPM:Date>%s</RPM:Date>\n", date);
2297: fprintf(rdf, " <RPM:Size>%s</RPM:Size>\n", size);
2298: fprintf(rdf, " <RPM:Subdir>%s</RPM:Subdir>\n", subdir);
2299: fprintf(rdf, " </rdf:Description>\n");
1.43 veillard 2300: debugFree(psubdir);
1.41 veillard 2301: }
1.42 veillard 2302: fprintf(rdf, "</rdf:RDF>\n");
2303: fclose(rdf);
1.41 veillard 2304: }
2305:
1.6 veillard 2306: void sql_show_config(void) {
2307: MYSQL_RES *result;
2308: MYSQL_ROW row;
1.8 veillard 2309: int id, i;
2310: int index = 0;
2311: int ids[500];
2312: char query[SMALL_QUERY];
1.6 veillard 2313:
2314:
1.8 veillard 2315: printf(";\n; Configuration file for rpm2html\n");
2316: printf("; http://rpmfind.net/linux/rpm2html/\n;\n\n");
2317: mysql_query(sql,"SELECT Name,Value FROM Config");
1.6 veillard 2318: result = mysql_use_result(sql);
2319:
2320: while((row = mysql_fetch_row(result)))
2321: {
1.8 veillard 2322: if (row[0] == NULL) {
2323: printf("\n");
2324: } else {
2325: if (!strcmp(row[0], "maint"))
2326: printf("; maintainer of the local rpm mirror\n");
2327: else if (!strcmp(row[0], "mail"))
2328: printf("; mail for the maintainer\n");
2329: else if (!strcmp(row[0], "dir"))
2330: printf("; Directory to store the HTML pages produced\n");
2331: else if (!strcmp(row[0], "url"))
2332: printf("; The relative URL for front pages\n");
2333: else if (!strcmp(row[0], "header"))
2334: printf("; Extra link in the navigation bar\n");
2335: else if (!strcmp(row[0], "html"))
2336: printf("; Export the local packages in HTML format\n");
2337: else if (!strcmp(row[0], "tree"))
2338: printf("; Build the tree for the distributions\n");
2339: else if (!strcmp(row[0], "rdf"))
2340: printf("; Export the local packages in RDF format\n");
2341: else if (!strcmp(row[0], "rdf_dir"))
2342: printf("; Directory to store the RDf tree\n");
2343: else if (!strcmp(row[0], "rdf_resources"))
2344: printf("; Compile a list of resources in RDF format\n");
2345: else if (!strcmp(row[0], "rdf_resources_dir"))
2346: printf("; Directory to store the RDf resources tree\n");
2347:
1.6 veillard 2348: if (row[1] == NULL)
1.8 veillard 2349: printf("%s\n\n", row[0]);
1.6 veillard 2350: else
1.8 veillard 2351: printf("%s=%s\n\n", row[0], row[1]);
2352: }
2353: }
2354: mysql_free_result(result);
2355: if(mysql_errno(sql)) {
2356: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2357: }
2358:
2359: /*
2360: * Dump the Metadata
2361: */
2362: printf(";\n; The metadata mirrors list\n;\n\n[metadata]\n");
2363: mysql_query(sql,"SELECT URL FROM Metadata");
2364: result = mysql_use_result(sql);
2365:
2366: while((row = mysql_fetch_row(result)))
2367: {
2368: if (row[0] != NULL) {
2369: printf("mirror=%s\n", row[0]);
1.6 veillard 2370: }
2371: }
1.8 veillard 2372: mysql_free_result(result);
1.6 veillard 2373: if(mysql_errno(sql)) {
2374: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2375: }
2376:
1.8 veillard 2377: /*
2378: * Dump the distributions informations
2379: * 1/ collect the list of IDs for the distribs
2380: */
2381: printf("\n\n;\n; The distribution list\n;\n\n");
2382: mysql_query(sql,"SELECT ID FROM Distribs");
2383: result = mysql_use_result(sql);
2384:
2385: while((row = mysql_fetch_row(result)))
2386: {
2387: if (row[0] != NULL) {
2388: if (sscanf(row[0], "%d", &id) == 1) {
2389: ids[index++] = id;
2390: }
2391: }
2392: }
2393: mysql_free_result(result);
2394:
2395: /*
2396: * Dump each distribution separately.
2397: */
2398: for (i = 0;i < index;i++) {
2399:
2400: snprintf(query, SMALL_QUERY - 1,
1.10 veillard 2401: "SELECT Directory,Name,Vendor,Path,URL,URLSrc,Description,Html,Color \
1.8 veillard 2402: FROM Distribs WHERE ID=%d", ids[i]);
2403: query[SMALL_QUERY - 1] = 0;
2404: if (mysql_query(sql,query)) {
2405: printf("sql_show_config: SELECT Distrib %d failed: %s\n",
2406: ids[i], mysql_error(sql));
2407: continue;
2408: }
2409:
2410: result = mysql_use_result(sql);
2411: if (result) {
2412: while((row = mysql_fetch_row(result)))
2413: {
2414: if (row[0] == NULL)
2415: break;
2416: printf("[%s]\n", row[0]);
2417: if (row[1] != NULL)
2418: printf("name=%s\n", row[1]);
2419: if (row[3] != NULL)
2420: printf("subdir=%s\n", row[3]);
2421: if (row[4] != NULL)
2422: printf("ftp=%s\n", row[4]);
2423: if (row[5] != NULL)
2424: printf("ftpsrc=%s\n", row[5]);
1.10 veillard 2425: if (row[7] != NULL)
2426: printf("html=%s\n", row[7]);
2427: if (row[8] != NULL)
2428: printf("color=%s\n", row[8]);
1.8 veillard 2429: }
2430: }
2431: mysql_free_result(result);
1.12 veillard 2432:
2433: /*
2434: * Extract the mirrors for this distribution.
2435: */
2436: snprintf(query, SMALL_QUERY - 1,
2437: "SELECT URL FROM Mirrors WHERE ID=%d", ids[i]);
2438: query[SMALL_QUERY - 1] = 0;
2439: if (mysql_query(sql,query)) {
2440: printf("sql_show_config: SELECT Mirrors %d failed: %s\n",
2441: ids[i], mysql_error(sql));
2442: printf("\n\n");
2443: continue;
2444: }
2445: result = mysql_use_result(sql);
2446: if (result) {
2447: while((row = mysql_fetch_row(result)))
2448: {
2449: if (row[0] == NULL)
2450: continue;
2451: printf("mirror=%s\n", row[0]);
2452: }
2453: }
2454: mysql_free_result(result);
2455:
1.8 veillard 2456: printf("\n\n");
2457: }
2458:
2459: printf(";\n; End of the configuration file for rpm2html\n;\n");
1.6 veillard 2460: }
2461:
2462: void sql_show_metadata(void) {
2463: MYSQL_RES *result;
2464: MYSQL_ROW row;
2465:
2466:
2467: mysql_query(sql,"SELECT URL FROM Metadata");
2468: result = mysql_use_result(sql);
2469:
2470: while((row = mysql_fetch_row(result)))
2471: {
2472: if (row[0] == NULL)
2473: printf("NULL !\n");
2474: else {
2475: printf("%s\n", row[0]);
2476: }
2477: }
2478: if(mysql_errno(sql)) {
2479: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2480: }
2481:
2482: }
2483:
2484: void sql_show_mirrors(void) {
2485: MYSQL_RES *result;
2486: MYSQL_ROW row;
2487:
2488:
2489: mysql_query(sql,"SELECT URL FROM Mirrors");
2490: result = mysql_use_result(sql);
2491:
2492: while((row = mysql_fetch_row(result)))
2493: {
2494: if (row[0] == NULL)
2495: printf("NULL !\n");
2496: else {
2497: printf("%s\n", row[0]);
2498: }
2499: }
2500: if(mysql_errno(sql)) {
2501: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2502: }
2503: }
2504:
1.5 veillard 2505: void sql_show_vendors(void) {
1.1 veillard 2506: MYSQL_RES *result;
2507: MYSQL_ROW row;
2508:
2509:
2510: mysql_query(sql,"SELECT Name, URL FROM Vendors");
2511: result = mysql_use_result(sql);
2512:
2513: while((row = mysql_fetch_row(result)))
2514: {
2515: if (row[0] == NULL)
2516: printf("NULL !\n");
2517: else {
2518: if (row[1] == NULL)
2519: printf("%s : no url\n", row[0]);
2520: else
2521: printf("%s : %s\n", row[0], row[1]);
2522: }
2523: }
2524: if(mysql_errno(sql)) {
2525: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2526: }
2527:
2528: }
2529:
1.5 veillard 2530: void sql_show_distribs(void) {
1.1 veillard 2531: MYSQL_RES *result;
2532: MYSQL_ROW row;
2533:
2534:
2535: mysql_query(sql,"SELECT Name, Path, URL FROM Distribs");
2536: result = mysql_use_result(sql);
2537:
2538: while((row = mysql_fetch_row(result)))
2539: {
2540: if (row[0] == NULL)
2541: printf("NULL !\n");
2542: else {
2543: if (row[1] == NULL)
2544: printf("%s : no Path\n", row[0]);
2545: else {
2546: if (row[2] == NULL)
2547: printf("%s : %s : no url\n", row[0], row[1]);
2548: else
2549: printf("%s : %s : %s\n", row[0], row[1], row[2]);
2550: }
2551: }
2552: }
2553: if(mysql_errno(sql)) {
2554: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2555: }
2556:
2557: }
2558:
1.5 veillard 2559: int sql_show_table_stats(const char *table, const char *key) {
1.6 veillard 2560: char query[MAX_QUERY];
1.2 veillard 2561: MYSQL_RES *result;
2562: MYSQL_ROW row;
2563: int res;
2564:
2565: /*
2566: * Search first for the ID if it already exists
2567: */
1.6 veillard 2568: snprintf(query, MAX_QUERY - 1, "SELECT COUNT(%s) FROM %s", key, table);
2569: query[MAX_QUERY - 1] = 0;
1.2 veillard 2570: if (mysql_query(sql,query)) {
1.5 veillard 2571: printf("sql_show_table_stats: SELECT COUNT failed: %s\n",
1.2 veillard 2572: mysql_error(sql));
2573: return(-1);
2574: }
2575:
2576: result = mysql_use_result(sql);
2577: if (result) {
2578: while((row = mysql_fetch_row(result)))
2579: {
2580: /*
2581: * Lookup the value and return it
2582: */
2583: if (row[0] == NULL) {
2584: mysql_free_result(result);
1.5 veillard 2585: printf("sql_show_table_stats: select count returns NULL !\n");
1.2 veillard 2586: return(-1);
2587: }
2588: if (sscanf(row[0], "%d", &res) != 1) {
2589: mysql_free_result(result);
1.5 veillard 2590: printf("sql_show_table_stats: value non numeric %s\n", row[0]);
1.2 veillard 2591: return(-1);
2592: }
2593: mysql_free_result(result);
2594: if (res <= 0)
2595: printf(" %s is empty\n", table);
2596: else
2597: printf(" %s contains %d records\n", table, res);
2598: return(res);
2599: }
2600: mysql_free_result(result);
2601: }
2602: if(mysql_errno(sql)) {
1.5 veillard 2603: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.2 veillard 2604: }
2605: return(-1);
2606: }
2607:
1.5 veillard 2608: int sql_show_stats(void) {
1.2 veillard 2609: const char *query = "SHOW TABLES";
2610: MYSQL_RES *result;
2611: MYSQL_ROW row;
2612:
2613: int tables = 0;
2614: int records = 0;
2615:
2616: if (mysql_query(sql,query)) {
2617: printf("sql_check_tables: SHOW TABLES failed %s\n",
2618: mysql_error(sql));
2619: return(-1);
2620: }
2621:
2622: result = mysql_use_result(sql);
2623: if (result) {
2624: while((row = mysql_fetch_row(result)))
2625: {
2626: if (row[0] == NULL) {
2627: mysql_free_result(result);
2628: printf("sql_check_tables: SHOW TABLES returns NULL !\n");
2629: return(-1);
2630: }
2631: tables++;
2632: }
2633: mysql_free_result(result);
2634: }
2635: if(mysql_errno(sql)) {
1.5 veillard 2636: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.2 veillard 2637: }
2638: printf("%d tables in use\n", tables);
1.5 veillard 2639: records += sql_show_table_stats("Config", "Name");
2640: records += sql_show_table_stats("Distribs", "Name");
2641: records += sql_show_table_stats("Vendors", "Name");
2642: records += sql_show_table_stats("Mirrors", "URL");
2643: records += sql_show_table_stats("Metadata", "URL");
2644: records += sql_show_table_stats("Packages", "Name");
1.8 veillard 2645: records += sql_show_table_stats("Requires", "Resource");
2646: records += sql_show_table_stats("Provides", "Resource");
1.5 veillard 2647: records += sql_show_table_stats("Files", "Path");
1.2 veillard 2648: printf("Total: %d records\n", records);
2649: return(records);
2650: }
2651:
1.26 veillard 2652: void sql_show_latests(void) {
2653: rpmDataPtr list;
2654:
2655: list = sqlRpmByDate();
2656: if (list == NULL) {
2657: fprintf(stderr, "no package in database\n");
2658: return;
2659: }
1.28 daniel 2660: dumpRpmByDate(list, 0);
1.29 veillard 2661: }
2662:
1.40 veillard 2663:
2664: void sql_show_resources(void) {
2665: int i;
2666:
2667: sqlInitSqlDirList();
2668: sqlInitSqlResourceList();
1.42 veillard 2669: sqlInitSqlDistributionList();
2670: sqlInitSqlVendorList();
1.40 veillard 2671: for (i = 0;i < sqlResourceListLen;i++) {
2672: if (sqlResourceList[i] == NULL)
2673: break;
2674: dumpRessRedirHtml(sqlResourceList[i]);
1.41 veillard 2675: if (rpm2html_dump_rdf_resources)
2676: sql_dump_rdf(sqlResourceList[i]);
1.40 veillard 2677: }
1.44 ! daniel 2678: if (rpm2htmlVerbose)
! 2679: fprintf(stderr, "Dumped %d redirrect resource pages\n", i);
1.40 veillard 2680: }
2681:
1.29 veillard 2682: void sql_show_all(void) {
2683: rpmDataPtr list;
1.31 veillard 2684: #ifdef SQL_DEBUG_TIMING
2685: time_t cur, last;
1.29 veillard 2686:
1.31 veillard 2687: last = time(NULL);
2688: #endif
1.29 veillard 2689: list = sqlRpmAll();
2690: if (list == NULL) {
2691: fprintf(stderr, "no package in database\n");
2692: return;
2693: }
1.31 veillard 2694: #ifdef SQL_DEBUG_TIMING
2695: cur = time(NULL);
2696: fprintf(stderr, "sqlRpmAll took %d seconds\n", (int)(cur - last));
2697: last = cur;
2698: #endif
2699:
2700: rpmNameSort(&list, 0);
2701: dumpRpmByName(rpmSoftwareList, 0);
2702:
2703: #ifdef SQL_DEBUG_TIMING
2704: cur = time(NULL);
2705: fprintf(stderr, "dumpRpmByName took %d seconds\n", (int)(cur - last));
2706: last = cur;
2707: #endif
2708:
2709: rpmGroupSort(&list, 0);
1.32 daniel 2710: dumpRpmByGroups(rpmSoftwareList, 0);
1.31 veillard 2711:
2712: #ifdef SQL_DEBUG_TIMING
2713: cur = time(NULL);
2714: fprintf(stderr, "dumpRpmByGroups took %d seconds\n", (int)(cur - last));
2715: last = cur;
2716: #endif
1.35 veillard 2717:
2718: rpmVendorSort(&list, 0);
2719: dumpRpmByVendors(list, 0);
2720:
2721: #ifdef SQL_DEBUG_TIMING
2722: cur = time(NULL);
2723: fprintf(stderr, "dumpRpmByVendors took %d seconds\n", (int)(cur - last));
1.36 veillard 2724: last = cur;
2725: #endif
2726:
2727: rpmDistribSort(&list, 0);
2728: dumpRpmByDistribs(list, 0);
2729:
2730: #ifdef SQL_DEBUG_TIMING
2731: cur = time(NULL);
2732: fprintf(stderr, "dumpRpmByDistribs took %d seconds\n", (int)(cur - last));
1.35 veillard 2733: last = cur;
2734: #endif
2735:
1.39 daniel 2736: rpmDateSort(&list, 0);
1.37 veillard 2737: dumpRpmByDate(list, 0);
2738:
2739: #ifdef SQL_DEBUG_TIMING
2740: cur = time(NULL);
2741: fprintf(stderr, "dumpRpmByDate took %d seconds\n", (int)(cur - last));
2742: last = cur;
2743: #endif
2744:
1.40 veillard 2745: rpmdataCleanup();
2746: sleep(30);
1.26 veillard 2747: }
2748:
1.2 veillard 2749: /************************************************************************
2750: * *
2751: * rpm2html configuration functions *
2752: * *
2753: ************************************************************************/
2754:
2755: int readConfigSql(void) {
1.6 veillard 2756: char query[MAX_QUERY];
1.3 veillard 2757: MYSQL_RES *result;
2758: MYSQL_ROW row;
1.4 veillard 2759: int dir = 0;
1.3 veillard 2760:
1.2 veillard 2761: /*
1.3 veillard 2762: * General configuration informations
1.2 veillard 2763: */
1.6 veillard 2764: snprintf(query, MAX_QUERY - 1, "SELECT Name,Value FROM Config");
2765: query[MAX_QUERY - 1] = 0;
1.3 veillard 2766: if (mysql_query(sql,query)) {
2767: printf("sql_check_tables: SELECT Config failed %s\n",
2768: mysql_error(sql));
2769: return(-1);
2770: }
2771:
2772: result = mysql_use_result(sql);
2773: if (result) {
2774: while((row = mysql_fetch_row(result)))
2775: {
2776: if ((row[0] == NULL) || (row[1] == NULL)) {
2777: fprintf(stderr, "readConfigSql : found NULL value\n");
2778: continue;
2779: }
1.4 veillard 2780: if (!strcmp(row[0], "dir"))
2781: dir = 1;
1.3 veillard 2782: addConfigEntry(RPM2HTML_NAME, row[0], row[1]);
2783: }
2784: mysql_free_result(result);
2785: }
2786: if(mysql_errno(sql)) {
1.5 veillard 2787: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.4 veillard 2788: }
2789: if (dir == 0) {
2790: fprintf(stderr, "readConfigSql : no directory\n");
2791: return(-1);
1.3 veillard 2792: }
2793:
2794: /*
2795: * The metadata mirror list.
2796: */
1.6 veillard 2797: snprintf(query, MAX_QUERY - 1, "SELECT URL FROM Metadata");
2798: query[MAX_QUERY - 1] = 0;
1.3 veillard 2799: if (mysql_query(sql,query)) {
2800: printf("sql_check_tables: SELECT Metadata failed %s\n",
2801: mysql_error(sql));
2802: return(-1);
2803: }
2804:
2805: result = mysql_use_result(sql);
2806: if (result) {
2807: while((row = mysql_fetch_row(result)))
2808: {
2809: if (row[0] == NULL) {
2810: fprintf(stderr, "readConfigSql : found NULL metadata\n");
2811: continue;
2812: }
2813: addConfigEntry("metadata", "mirror", row[0]);
2814: }
2815: mysql_free_result(result);
2816: }
2817: if(mysql_errno(sql)) {
1.5 veillard 2818: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 2819: }
2820:
2821: /*
2822: * The distribution lists
2823: */
1.6 veillard 2824: snprintf(query, MAX_QUERY - 1, "SELECT Directory,Name,URL,URLSrc,Path FROM Distribs");
2825: query[MAX_QUERY - 1] = 0;
1.3 veillard 2826: if (mysql_query(sql,query)) {
2827: printf("sql_check_tables: SELECT Distribs failed %s\n",
2828: mysql_error(sql));
2829: return(-1);
2830: }
2831:
2832: result = mysql_use_result(sql);
2833: if (result) {
2834: while((row = mysql_fetch_row(result)))
2835: {
2836: if (row[0] == NULL) {
2837: fprintf(stderr, "readConfigSql : found NULL distro\n");
2838: continue;
2839: }
2840:
2841: if (row[1] != NULL)
2842: addConfigEntry(row[0], "name", row[1]);
2843: if (row[2] != NULL)
2844: addConfigEntry(row[0], "ftp", row[2]);
2845: if (row[3] != NULL)
2846: addConfigEntry(row[0], "ftp", row[3]);
2847: if (row[4] != NULL)
2848: addConfigEntry(row[0], "subdir", row[4]);
2849: }
2850: mysql_free_result(result);
2851: }
2852: if(mysql_errno(sql)) {
1.5 veillard 2853: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 2854: }
2855:
2856: /*
2857: * The Mirrors
2858: */
1.6 veillard 2859: snprintf(query, MAX_QUERY - 1, "SELECT Distribs.Directory,Mirrors.URL FROM Distribs,Mirrors WHERE Distribs.ID = Mirrors.ID");
2860: query[MAX_QUERY - 1] = 0;
1.3 veillard 2861: if (mysql_query(sql,query)) {
2862: printf("sql_check_tables: SELECT Distribs failed %s\n",
2863: mysql_error(sql));
2864: return(-1);
2865: }
2866:
2867: result = mysql_use_result(sql);
2868: if (result) {
2869: while((row = mysql_fetch_row(result)))
2870: {
2871: if ((row[0] == NULL) || (row[1] == NULL)) {
2872: fprintf(stderr, "readConfigSql : found NULL mirror\n");
2873: continue;
2874: }
2875:
2876: addConfigEntry(row[0], "mirror", row[1]);
2877: }
2878: mysql_free_result(result);
2879: }
2880: if(mysql_errno(sql)) {
1.5 veillard 2881: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 2882: }
2883:
1.5 veillard 2884: /*
2885: * TODO: add the language(s) stuff
2886: */
1.3 veillard 2887: return(0);
1.2 veillard 2888: }
2889:
2890: void sqlConfigEntry(const char *rpmdir, const char *name, const char *value) {
2891: int distrib;
2892:
2893: if (rpm2htmlVerbose > 1)
2894: printf("sqlConfigEntry(\"%s\", \"%s\", \"%s\")\n", rpmdir, name, value);
2895:
2896: /*
2897: * case of global option for rpm2html.
2898: */
2899: if (!strcasecmp(rpmdir, RPM2HTML_NAME)) {
1.5 veillard 2900: sql_add_config_info(name, value);
1.2 veillard 2901: return;
2902: }
2903:
2904: /*
2905: * Options for the metadata mirrors.
2906: */
2907: if (!strcasecmp(rpmdir, "metadata")) {
2908: if (!strcasecmp(name, "mirror")) {
1.5 veillard 2909: sql_add_metadata_base(value);
1.2 veillard 2910: } else {
2911: printf("Config file : %s entry for [metadata] ignored\n", name);
2912: }
2913: return;
2914: }
2915:
2916: /*
2917: * option for a directory.
2918: */
2919: if (!strcasecmp(name, "name")) {
1.9 veillard 2920: sql_add_distrib(value, NULL, rpmdir, NULL, NULL, NULL, NULL,
2921: NULL, NULL);
1.2 veillard 2922: } else if (!strcasecmp(name, "subdir")) {
2923: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2924: if (distrib > 0)
2925: sql_update_id("Distribs", distrib, "Path", value);
2926: } else if (!strcasecmp(name, "url")) {
2927: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2928: if (distrib > 0)
2929: sql_update_id("Distribs", distrib, "URL", value);
2930: } else if (!strcasecmp(name, "ftp")) {
2931: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2932: if (distrib > 0)
2933: sql_update_id("Distribs", distrib, "URL", value);
2934: } else if (!strcasecmp(name, "ftpsrc")) {
2935: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2936: if (distrib > 0)
2937: sql_update_id("Distribs", distrib, "URLSrc", value);
1.9 veillard 2938: } else if (!strcasecmp(name, "html")) {
2939: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2940: if (distrib > 0)
2941: sql_update_id("Distribs", distrib, "Html", value);
2942: } else if (!strcasecmp(name, "color")) {
2943: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2944: if (distrib > 0)
2945: sql_update_id("Distribs", distrib, "Color", value);
1.2 veillard 2946: } else if (!strcasecmp(name, "mirror")) {
2947: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2948: if (distrib > 0)
1.5 veillard 2949: sql_add_dist_mirror(distrib, value, 0);
1.2 veillard 2950: } else {
2951: printf("Config file : %s entry for [%s] ignored\n", name, rpmdir);
2952: }
2953: }
1.1 veillard 2954:
Webmaster