Annotation of rpm2html/sql.c, revision 1.42
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:
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;
2159: char *subdir;
1.42 ! veillard 2160: char *psubdir;
! 2161: char *rpmdir;
! 2162: char *start, *end;
1.41 veillard 2163: int distrib;
1.42 ! veillard 2164: int vendor;
! 2165: int len;
! 2166: char path[500];
1.41 veillard 2167:
2168: if (resource == NULL)
2169: return;
2170: if (!rpm2html_dump_rdf_resources)
2171: return;
1.42 ! veillard 2172: if (!rpm2html_rdf_resources_dir)
! 2173: return;
1.41 veillard 2174: if ((rpm2html_host == NULL) || (rpm2html_url == NULL))
2175: return;
2176:
1.42 ! veillard 2177: /*
! 2178: * Open the RDF resource descritpion.
! 2179: */
! 2180: mkdir(rpm2html_rdf_resources_dir, 0755);
! 2181: snprintf(path, 500, "%s/%s.rdf",
! 2182: rpm2html_rdf_resources_dir, resource);
! 2183: path[499] = 0;
! 2184: rdf = fopen(path, "w");
! 2185: if (rdf == NULL) {
! 2186: fprintf(stderr, "unable to write to %s\n", path);
! 2187: return;
! 2188: }
! 2189: fprintf(rdf, "<?xml version=\"1.0\"?>\n");
! 2190: 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");
! 2191:
! 2192: /*
! 2193: * Query the database for the informations providing the resource.
! 2194: */
1.41 veillard 2195: snprintf(query, SMALL_QUERY,
2196: "select filename,Dist,Name,Version,Release,Arch,Os,Packager,Date,Size from Packages where Name=\"%s\"",
2197: resource);
2198: query[SMALL_QUERY - 1] = 0;
2199: if (mysql_query(sql, query)) {
2200: printf("sql_dump_rdf: SELECT from Packages failed: %s\n",
2201: mysql_error(sql));
1.42 ! veillard 2202: fprintf(rdf, "</rdf:RDF>\n");
! 2203: fclose(rdf);
1.41 veillard 2204: return;
2205: }
2206: result = mysql_use_result(sql);
2207: if (result == NULL) {
2208: printf("sql_dump_rdf: SELECT from Packages failed: %s\n",
2209: mysql_error(sql));
1.42 ! veillard 2210: fprintf(rdf, "</rdf:RDF>\n");
! 2211: fclose(rdf);
1.41 veillard 2212: return;
2213: }
2214: while((row = mysql_fetch_row(result))) {
2215: filename = row[0];
2216: dist = row[1];
2217: name = row[2];
2218: version = row[3];
2219: release = row[4];
2220: arch = row[5];
2221: os = row[6];
2222: packager = row[7];
2223: date = row[8];
2224: size = row[9];
2225: if ((filename == NULL) || (dist == NULL) || (name == NULL) ||
2226: (version == NULL) || (release == NULL) || (arch == NULL) ||
1.42 ! veillard 2227: (os == NULL) || (date == NULL) ||
1.41 veillard 2228: (size == NULL)) {
2229: continue;
2230: }
1.42 ! veillard 2231: if (!strncmp(filename, "localbase", 9))
! 2232: continue;
1.41 veillard 2233: if (sscanf(dist, "%d", &distrib) != 1)
2234: continue;
1.42 ! veillard 2235: if ((distrib < 1) || (distrib >= sqlVendorListLen) ||
! 2236: (sqlVendorList[distrib] == NULL))
! 2237: continue;
! 2238: if (packager != NULL) {
! 2239: if (sscanf(packager, "%d", &vendor) != 1)
! 2240: continue;
! 2241: }
! 2242: if ((vendor < 1) || (vendor >= sqlDistributionListLen) ||
! 2243: (sqlDistributionList[vendor] == NULL))
1.41 veillard 2244: continue;
2245:
2246: subdir = sqlDirList[distrib]->subdir;
1.42 ! veillard 2247: rpmdir = sqlDirList[distrib]->rpmdir;
! 2248: len = strlen(rpmdir);
! 2249: if (strncmp(filename, rpmdir, len)) {
! 2250: fprintf(stderr, "%s out of subdir %s\n", filename, subdir);
! 2251: continue;
! 2252: }
! 2253: start = &(filename[len]);
! 2254: while (*start == '/') start++;
! 2255: end = &start[strlen(start) - 1];
! 2256: while ((end >= start) && (*end != '/')) end--;
! 2257: if (end <= start) {
! 2258: psubdir = debugStrdup("");
! 2259: } else {
! 2260: psubdir = debugMalloc((end - start) + 1);
! 2261: if (psubdir == NULL) {
! 2262: fprintf(stderr, "Out of memory\n");
! 2263: continue;
1.41 veillard 2264: }
1.42 ! veillard 2265: strncpy(psubdir, start, end - start);
! 2266: psubdir[end - start] = 0;
1.41 veillard 2267: }
1.42 ! veillard 2268: fprintf(rdf, " <rdf:Description about=\"%s/%s/%s-%s-%s.%s.rpm\" ",
! 2269: sqlDirList[distrib]->ftp,psubdir,name,version,release,arch);
! 2270: fprintf(rdf, "href=\"../%s/%s/%s-%s-%s.%s.rdf\">\n",
! 2271: subdir,psubdir,name,version,release,arch);
! 2272: fprintf(rdf, " <RPM:Name>%s</RPM:Name>\n", name);
! 2273: fprintf(rdf, " <RPM:Version>%s</RPM:Version>\n", version);
! 2274: fprintf(rdf, " <RPM:Release>%s</RPM:Release>\n", release);
! 2275: fprintf(rdf, " <RPM:Arch>%s</RPM:Arch>\n", arch);
! 2276: fprintf(rdf, " <RPM:Os>%s</RPM:Os>\n", os);
! 2277: if (packager == NULL)
! 2278: fprintf(rdf, " <RPM:Distribution>Unknown</RPM:Distribution>\n");
! 2279: else
! 2280: fprintf(rdf, " <RPM:Distribution>%s</RPM:Distribution>\n",
! 2281: sqlDistributionList[vendor]);
! 2282: fprintf(rdf, " <RPM:Vendor>%s</RPM:Vendor>\n",
! 2283: sqlVendorList[distrib]);
! 2284: fprintf(rdf, " <RPM:Date>%s</RPM:Date>\n", date);
! 2285: fprintf(rdf, " <RPM:Size>%s</RPM:Size>\n", size);
! 2286: fprintf(rdf, " <RPM:Subdir>%s</RPM:Subdir>\n", subdir);
! 2287: fprintf(rdf, " </rdf:Description>\n");
! 2288: xmlFree(psubdir);
1.41 veillard 2289: }
1.42 ! veillard 2290: fprintf(rdf, "</rdf:RDF>\n");
! 2291: fclose(rdf);
1.41 veillard 2292: }
2293:
1.6 veillard 2294: void sql_show_config(void) {
2295: MYSQL_RES *result;
2296: MYSQL_ROW row;
1.8 veillard 2297: int id, i;
2298: int index = 0;
2299: int ids[500];
2300: char query[SMALL_QUERY];
1.6 veillard 2301:
2302:
1.8 veillard 2303: printf(";\n; Configuration file for rpm2html\n");
2304: printf("; http://rpmfind.net/linux/rpm2html/\n;\n\n");
2305: mysql_query(sql,"SELECT Name,Value FROM Config");
1.6 veillard 2306: result = mysql_use_result(sql);
2307:
2308: while((row = mysql_fetch_row(result)))
2309: {
1.8 veillard 2310: if (row[0] == NULL) {
2311: printf("\n");
2312: } else {
2313: if (!strcmp(row[0], "maint"))
2314: printf("; maintainer of the local rpm mirror\n");
2315: else if (!strcmp(row[0], "mail"))
2316: printf("; mail for the maintainer\n");
2317: else if (!strcmp(row[0], "dir"))
2318: printf("; Directory to store the HTML pages produced\n");
2319: else if (!strcmp(row[0], "url"))
2320: printf("; The relative URL for front pages\n");
2321: else if (!strcmp(row[0], "header"))
2322: printf("; Extra link in the navigation bar\n");
2323: else if (!strcmp(row[0], "html"))
2324: printf("; Export the local packages in HTML format\n");
2325: else if (!strcmp(row[0], "tree"))
2326: printf("; Build the tree for the distributions\n");
2327: else if (!strcmp(row[0], "rdf"))
2328: printf("; Export the local packages in RDF format\n");
2329: else if (!strcmp(row[0], "rdf_dir"))
2330: printf("; Directory to store the RDf tree\n");
2331: else if (!strcmp(row[0], "rdf_resources"))
2332: printf("; Compile a list of resources in RDF format\n");
2333: else if (!strcmp(row[0], "rdf_resources_dir"))
2334: printf("; Directory to store the RDf resources tree\n");
2335:
1.6 veillard 2336: if (row[1] == NULL)
1.8 veillard 2337: printf("%s\n\n", row[0]);
1.6 veillard 2338: else
1.8 veillard 2339: printf("%s=%s\n\n", row[0], row[1]);
2340: }
2341: }
2342: mysql_free_result(result);
2343: if(mysql_errno(sql)) {
2344: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2345: }
2346:
2347: /*
2348: * Dump the Metadata
2349: */
2350: printf(";\n; The metadata mirrors list\n;\n\n[metadata]\n");
2351: mysql_query(sql,"SELECT URL FROM Metadata");
2352: result = mysql_use_result(sql);
2353:
2354: while((row = mysql_fetch_row(result)))
2355: {
2356: if (row[0] != NULL) {
2357: printf("mirror=%s\n", row[0]);
1.6 veillard 2358: }
2359: }
1.8 veillard 2360: mysql_free_result(result);
1.6 veillard 2361: if(mysql_errno(sql)) {
2362: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2363: }
2364:
1.8 veillard 2365: /*
2366: * Dump the distributions informations
2367: * 1/ collect the list of IDs for the distribs
2368: */
2369: printf("\n\n;\n; The distribution list\n;\n\n");
2370: mysql_query(sql,"SELECT ID FROM Distribs");
2371: result = mysql_use_result(sql);
2372:
2373: while((row = mysql_fetch_row(result)))
2374: {
2375: if (row[0] != NULL) {
2376: if (sscanf(row[0], "%d", &id) == 1) {
2377: ids[index++] = id;
2378: }
2379: }
2380: }
2381: mysql_free_result(result);
2382:
2383: /*
2384: * Dump each distribution separately.
2385: */
2386: for (i = 0;i < index;i++) {
2387:
2388: snprintf(query, SMALL_QUERY - 1,
1.10 veillard 2389: "SELECT Directory,Name,Vendor,Path,URL,URLSrc,Description,Html,Color \
1.8 veillard 2390: FROM Distribs WHERE ID=%d", ids[i]);
2391: query[SMALL_QUERY - 1] = 0;
2392: if (mysql_query(sql,query)) {
2393: printf("sql_show_config: SELECT Distrib %d failed: %s\n",
2394: ids[i], mysql_error(sql));
2395: continue;
2396: }
2397:
2398: result = mysql_use_result(sql);
2399: if (result) {
2400: while((row = mysql_fetch_row(result)))
2401: {
2402: if (row[0] == NULL)
2403: break;
2404: printf("[%s]\n", row[0]);
2405: if (row[1] != NULL)
2406: printf("name=%s\n", row[1]);
2407: if (row[3] != NULL)
2408: printf("subdir=%s\n", row[3]);
2409: if (row[4] != NULL)
2410: printf("ftp=%s\n", row[4]);
2411: if (row[5] != NULL)
2412: printf("ftpsrc=%s\n", row[5]);
1.10 veillard 2413: if (row[7] != NULL)
2414: printf("html=%s\n", row[7]);
2415: if (row[8] != NULL)
2416: printf("color=%s\n", row[8]);
1.8 veillard 2417: }
2418: }
2419: mysql_free_result(result);
1.12 veillard 2420:
2421: /*
2422: * Extract the mirrors for this distribution.
2423: */
2424: snprintf(query, SMALL_QUERY - 1,
2425: "SELECT URL FROM Mirrors WHERE ID=%d", ids[i]);
2426: query[SMALL_QUERY - 1] = 0;
2427: if (mysql_query(sql,query)) {
2428: printf("sql_show_config: SELECT Mirrors %d failed: %s\n",
2429: ids[i], mysql_error(sql));
2430: printf("\n\n");
2431: continue;
2432: }
2433: result = mysql_use_result(sql);
2434: if (result) {
2435: while((row = mysql_fetch_row(result)))
2436: {
2437: if (row[0] == NULL)
2438: continue;
2439: printf("mirror=%s\n", row[0]);
2440: }
2441: }
2442: mysql_free_result(result);
2443:
1.8 veillard 2444: printf("\n\n");
2445: }
2446:
2447: printf(";\n; End of the configuration file for rpm2html\n;\n");
1.6 veillard 2448: }
2449:
2450: void sql_show_metadata(void) {
2451: MYSQL_RES *result;
2452: MYSQL_ROW row;
2453:
2454:
2455: mysql_query(sql,"SELECT URL FROM Metadata");
2456: result = mysql_use_result(sql);
2457:
2458: while((row = mysql_fetch_row(result)))
2459: {
2460: if (row[0] == NULL)
2461: printf("NULL !\n");
2462: else {
2463: printf("%s\n", row[0]);
2464: }
2465: }
2466: if(mysql_errno(sql)) {
2467: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2468: }
2469:
2470: }
2471:
2472: void sql_show_mirrors(void) {
2473: MYSQL_RES *result;
2474: MYSQL_ROW row;
2475:
2476:
2477: mysql_query(sql,"SELECT URL FROM Mirrors");
2478: result = mysql_use_result(sql);
2479:
2480: while((row = mysql_fetch_row(result)))
2481: {
2482: if (row[0] == NULL)
2483: printf("NULL !\n");
2484: else {
2485: printf("%s\n", row[0]);
2486: }
2487: }
2488: if(mysql_errno(sql)) {
2489: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2490: }
2491: }
2492:
1.5 veillard 2493: void sql_show_vendors(void) {
1.1 veillard 2494: MYSQL_RES *result;
2495: MYSQL_ROW row;
2496:
2497:
2498: mysql_query(sql,"SELECT Name, URL FROM Vendors");
2499: result = mysql_use_result(sql);
2500:
2501: while((row = mysql_fetch_row(result)))
2502: {
2503: if (row[0] == NULL)
2504: printf("NULL !\n");
2505: else {
2506: if (row[1] == NULL)
2507: printf("%s : no url\n", row[0]);
2508: else
2509: printf("%s : %s\n", row[0], row[1]);
2510: }
2511: }
2512: if(mysql_errno(sql)) {
2513: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2514: }
2515:
2516: }
2517:
1.5 veillard 2518: void sql_show_distribs(void) {
1.1 veillard 2519: MYSQL_RES *result;
2520: MYSQL_ROW row;
2521:
2522:
2523: mysql_query(sql,"SELECT Name, Path, URL FROM Distribs");
2524: result = mysql_use_result(sql);
2525:
2526: while((row = mysql_fetch_row(result)))
2527: {
2528: if (row[0] == NULL)
2529: printf("NULL !\n");
2530: else {
2531: if (row[1] == NULL)
2532: printf("%s : no Path\n", row[0]);
2533: else {
2534: if (row[2] == NULL)
2535: printf("%s : %s : no url\n", row[0], row[1]);
2536: else
2537: printf("%s : %s : %s\n", row[0], row[1], row[2]);
2538: }
2539: }
2540: }
2541: if(mysql_errno(sql)) {
2542: fprintf(stderr, "Error: %s\n", mysql_error(sql));
2543: }
2544:
2545: }
2546:
1.5 veillard 2547: int sql_show_table_stats(const char *table, const char *key) {
1.6 veillard 2548: char query[MAX_QUERY];
1.2 veillard 2549: MYSQL_RES *result;
2550: MYSQL_ROW row;
2551: int res;
2552:
2553: /*
2554: * Search first for the ID if it already exists
2555: */
1.6 veillard 2556: snprintf(query, MAX_QUERY - 1, "SELECT COUNT(%s) FROM %s", key, table);
2557: query[MAX_QUERY - 1] = 0;
1.2 veillard 2558: if (mysql_query(sql,query)) {
1.5 veillard 2559: printf("sql_show_table_stats: SELECT COUNT failed: %s\n",
1.2 veillard 2560: mysql_error(sql));
2561: return(-1);
2562: }
2563:
2564: result = mysql_use_result(sql);
2565: if (result) {
2566: while((row = mysql_fetch_row(result)))
2567: {
2568: /*
2569: * Lookup the value and return it
2570: */
2571: if (row[0] == NULL) {
2572: mysql_free_result(result);
1.5 veillard 2573: printf("sql_show_table_stats: select count returns NULL !\n");
1.2 veillard 2574: return(-1);
2575: }
2576: if (sscanf(row[0], "%d", &res) != 1) {
2577: mysql_free_result(result);
1.5 veillard 2578: printf("sql_show_table_stats: value non numeric %s\n", row[0]);
1.2 veillard 2579: return(-1);
2580: }
2581: mysql_free_result(result);
2582: if (res <= 0)
2583: printf(" %s is empty\n", table);
2584: else
2585: printf(" %s contains %d records\n", table, res);
2586: return(res);
2587: }
2588: mysql_free_result(result);
2589: }
2590: if(mysql_errno(sql)) {
1.5 veillard 2591: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.2 veillard 2592: }
2593: return(-1);
2594: }
2595:
1.5 veillard 2596: int sql_show_stats(void) {
1.2 veillard 2597: const char *query = "SHOW TABLES";
2598: MYSQL_RES *result;
2599: MYSQL_ROW row;
2600:
2601: int tables = 0;
2602: int records = 0;
2603:
2604: if (mysql_query(sql,query)) {
2605: printf("sql_check_tables: SHOW TABLES failed %s\n",
2606: mysql_error(sql));
2607: return(-1);
2608: }
2609:
2610: result = mysql_use_result(sql);
2611: if (result) {
2612: while((row = mysql_fetch_row(result)))
2613: {
2614: if (row[0] == NULL) {
2615: mysql_free_result(result);
2616: printf("sql_check_tables: SHOW TABLES returns NULL !\n");
2617: return(-1);
2618: }
2619: tables++;
2620: }
2621: mysql_free_result(result);
2622: }
2623: if(mysql_errno(sql)) {
1.5 veillard 2624: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.2 veillard 2625: }
2626: printf("%d tables in use\n", tables);
1.5 veillard 2627: records += sql_show_table_stats("Config", "Name");
2628: records += sql_show_table_stats("Distribs", "Name");
2629: records += sql_show_table_stats("Vendors", "Name");
2630: records += sql_show_table_stats("Mirrors", "URL");
2631: records += sql_show_table_stats("Metadata", "URL");
2632: records += sql_show_table_stats("Packages", "Name");
1.8 veillard 2633: records += sql_show_table_stats("Requires", "Resource");
2634: records += sql_show_table_stats("Provides", "Resource");
1.5 veillard 2635: records += sql_show_table_stats("Files", "Path");
1.2 veillard 2636: printf("Total: %d records\n", records);
2637: return(records);
2638: }
2639:
1.26 veillard 2640: void sql_show_latests(void) {
2641: rpmDataPtr list;
2642:
2643: list = sqlRpmByDate();
2644: if (list == NULL) {
2645: fprintf(stderr, "no package in database\n");
2646: return;
2647: }
1.28 daniel 2648: dumpRpmByDate(list, 0);
1.29 veillard 2649: }
2650:
1.40 veillard 2651:
2652: void sql_show_resources(void) {
2653: int i;
2654:
2655: sqlInitSqlDirList();
2656: sqlInitSqlResourceList();
1.42 ! veillard 2657: sqlInitSqlDistributionList();
! 2658: sqlInitSqlVendorList();
1.40 veillard 2659: for (i = 0;i < sqlResourceListLen;i++) {
2660: if (sqlResourceList[i] == NULL)
2661: break;
2662: dumpRessRedirHtml(sqlResourceList[i]);
1.41 veillard 2663: if (rpm2html_dump_rdf_resources)
2664: sql_dump_rdf(sqlResourceList[i]);
1.40 veillard 2665: }
2666: fprintf(stderr, "Dumped %d redirrect resource pages\n", i);
2667: }
2668:
1.29 veillard 2669: void sql_show_all(void) {
2670: rpmDataPtr list;
1.31 veillard 2671: #ifdef SQL_DEBUG_TIMING
2672: time_t cur, last;
1.29 veillard 2673:
1.31 veillard 2674: last = time(NULL);
2675: #endif
1.29 veillard 2676: list = sqlRpmAll();
2677: if (list == NULL) {
2678: fprintf(stderr, "no package in database\n");
2679: return;
2680: }
1.31 veillard 2681: #ifdef SQL_DEBUG_TIMING
2682: cur = time(NULL);
2683: fprintf(stderr, "sqlRpmAll took %d seconds\n", (int)(cur - last));
2684: last = cur;
2685: #endif
2686:
2687: rpmNameSort(&list, 0);
2688: dumpRpmByName(rpmSoftwareList, 0);
2689:
2690: #ifdef SQL_DEBUG_TIMING
2691: cur = time(NULL);
2692: fprintf(stderr, "dumpRpmByName took %d seconds\n", (int)(cur - last));
2693: last = cur;
2694: #endif
2695:
2696: rpmGroupSort(&list, 0);
1.32 daniel 2697: dumpRpmByGroups(rpmSoftwareList, 0);
1.31 veillard 2698:
2699: #ifdef SQL_DEBUG_TIMING
2700: cur = time(NULL);
2701: fprintf(stderr, "dumpRpmByGroups took %d seconds\n", (int)(cur - last));
2702: last = cur;
2703: #endif
1.35 veillard 2704:
2705: rpmVendorSort(&list, 0);
2706: dumpRpmByVendors(list, 0);
2707:
2708: #ifdef SQL_DEBUG_TIMING
2709: cur = time(NULL);
2710: fprintf(stderr, "dumpRpmByVendors took %d seconds\n", (int)(cur - last));
1.36 veillard 2711: last = cur;
2712: #endif
2713:
2714: rpmDistribSort(&list, 0);
2715: dumpRpmByDistribs(list, 0);
2716:
2717: #ifdef SQL_DEBUG_TIMING
2718: cur = time(NULL);
2719: fprintf(stderr, "dumpRpmByDistribs took %d seconds\n", (int)(cur - last));
1.35 veillard 2720: last = cur;
2721: #endif
2722:
1.39 daniel 2723: rpmDateSort(&list, 0);
1.37 veillard 2724: dumpRpmByDate(list, 0);
2725:
2726: #ifdef SQL_DEBUG_TIMING
2727: cur = time(NULL);
2728: fprintf(stderr, "dumpRpmByDate took %d seconds\n", (int)(cur - last));
2729: last = cur;
2730: #endif
2731:
1.40 veillard 2732: rpmdataCleanup();
2733: sleep(30);
1.26 veillard 2734: }
2735:
1.2 veillard 2736: /************************************************************************
2737: * *
2738: * rpm2html configuration functions *
2739: * *
2740: ************************************************************************/
2741:
2742: int readConfigSql(void) {
1.6 veillard 2743: char query[MAX_QUERY];
1.3 veillard 2744: MYSQL_RES *result;
2745: MYSQL_ROW row;
1.4 veillard 2746: int dir = 0;
1.3 veillard 2747:
1.2 veillard 2748: /*
1.3 veillard 2749: * General configuration informations
1.2 veillard 2750: */
1.6 veillard 2751: snprintf(query, MAX_QUERY - 1, "SELECT Name,Value FROM Config");
2752: query[MAX_QUERY - 1] = 0;
1.3 veillard 2753: if (mysql_query(sql,query)) {
2754: printf("sql_check_tables: SELECT Config failed %s\n",
2755: mysql_error(sql));
2756: return(-1);
2757: }
2758:
2759: result = mysql_use_result(sql);
2760: if (result) {
2761: while((row = mysql_fetch_row(result)))
2762: {
2763: if ((row[0] == NULL) || (row[1] == NULL)) {
2764: fprintf(stderr, "readConfigSql : found NULL value\n");
2765: continue;
2766: }
1.4 veillard 2767: if (!strcmp(row[0], "dir"))
2768: dir = 1;
1.3 veillard 2769: addConfigEntry(RPM2HTML_NAME, row[0], row[1]);
2770: }
2771: mysql_free_result(result);
2772: }
2773: if(mysql_errno(sql)) {
1.5 veillard 2774: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.4 veillard 2775: }
2776: if (dir == 0) {
2777: fprintf(stderr, "readConfigSql : no directory\n");
2778: return(-1);
1.3 veillard 2779: }
2780:
2781: /*
2782: * The metadata mirror list.
2783: */
1.6 veillard 2784: snprintf(query, MAX_QUERY - 1, "SELECT URL FROM Metadata");
2785: query[MAX_QUERY - 1] = 0;
1.3 veillard 2786: if (mysql_query(sql,query)) {
2787: printf("sql_check_tables: SELECT Metadata failed %s\n",
2788: mysql_error(sql));
2789: return(-1);
2790: }
2791:
2792: result = mysql_use_result(sql);
2793: if (result) {
2794: while((row = mysql_fetch_row(result)))
2795: {
2796: if (row[0] == NULL) {
2797: fprintf(stderr, "readConfigSql : found NULL metadata\n");
2798: continue;
2799: }
2800: addConfigEntry("metadata", "mirror", row[0]);
2801: }
2802: mysql_free_result(result);
2803: }
2804: if(mysql_errno(sql)) {
1.5 veillard 2805: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 2806: }
2807:
2808: /*
2809: * The distribution lists
2810: */
1.6 veillard 2811: snprintf(query, MAX_QUERY - 1, "SELECT Directory,Name,URL,URLSrc,Path FROM Distribs");
2812: query[MAX_QUERY - 1] = 0;
1.3 veillard 2813: if (mysql_query(sql,query)) {
2814: printf("sql_check_tables: SELECT Distribs failed %s\n",
2815: mysql_error(sql));
2816: return(-1);
2817: }
2818:
2819: result = mysql_use_result(sql);
2820: if (result) {
2821: while((row = mysql_fetch_row(result)))
2822: {
2823: if (row[0] == NULL) {
2824: fprintf(stderr, "readConfigSql : found NULL distro\n");
2825: continue;
2826: }
2827:
2828: if (row[1] != NULL)
2829: addConfigEntry(row[0], "name", row[1]);
2830: if (row[2] != NULL)
2831: addConfigEntry(row[0], "ftp", row[2]);
2832: if (row[3] != NULL)
2833: addConfigEntry(row[0], "ftp", row[3]);
2834: if (row[4] != NULL)
2835: addConfigEntry(row[0], "subdir", row[4]);
2836: }
2837: mysql_free_result(result);
2838: }
2839: if(mysql_errno(sql)) {
1.5 veillard 2840: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 2841: }
2842:
2843: /*
2844: * The Mirrors
2845: */
1.6 veillard 2846: snprintf(query, MAX_QUERY - 1, "SELECT Distribs.Directory,Mirrors.URL FROM Distribs,Mirrors WHERE Distribs.ID = Mirrors.ID");
2847: query[MAX_QUERY - 1] = 0;
1.3 veillard 2848: if (mysql_query(sql,query)) {
2849: printf("sql_check_tables: SELECT Distribs failed %s\n",
2850: mysql_error(sql));
2851: return(-1);
2852: }
2853:
2854: result = mysql_use_result(sql);
2855: if (result) {
2856: while((row = mysql_fetch_row(result)))
2857: {
2858: if ((row[0] == NULL) || (row[1] == NULL)) {
2859: fprintf(stderr, "readConfigSql : found NULL mirror\n");
2860: continue;
2861: }
2862:
2863: addConfigEntry(row[0], "mirror", row[1]);
2864: }
2865: mysql_free_result(result);
2866: }
2867: if(mysql_errno(sql)) {
1.5 veillard 2868: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 2869: }
2870:
1.5 veillard 2871: /*
2872: * TODO: add the language(s) stuff
2873: */
1.3 veillard 2874: return(0);
1.2 veillard 2875: }
2876:
2877: void sqlConfigEntry(const char *rpmdir, const char *name, const char *value) {
2878: int distrib;
2879:
2880: if (rpm2htmlVerbose > 1)
2881: printf("sqlConfigEntry(\"%s\", \"%s\", \"%s\")\n", rpmdir, name, value);
2882:
2883: /*
2884: * case of global option for rpm2html.
2885: */
2886: if (!strcasecmp(rpmdir, RPM2HTML_NAME)) {
1.5 veillard 2887: sql_add_config_info(name, value);
1.2 veillard 2888: return;
2889: }
2890:
2891: /*
2892: * Options for the metadata mirrors.
2893: */
2894: if (!strcasecmp(rpmdir, "metadata")) {
2895: if (!strcasecmp(name, "mirror")) {
1.5 veillard 2896: sql_add_metadata_base(value);
1.2 veillard 2897: } else {
2898: printf("Config file : %s entry for [metadata] ignored\n", name);
2899: }
2900: return;
2901: }
2902:
2903: /*
2904: * option for a directory.
2905: */
2906: if (!strcasecmp(name, "name")) {
1.9 veillard 2907: sql_add_distrib(value, NULL, rpmdir, NULL, NULL, NULL, NULL,
2908: NULL, NULL);
1.2 veillard 2909: } else if (!strcasecmp(name, "subdir")) {
2910: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2911: if (distrib > 0)
2912: sql_update_id("Distribs", distrib, "Path", value);
2913: } else if (!strcasecmp(name, "url")) {
2914: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2915: if (distrib > 0)
2916: sql_update_id("Distribs", distrib, "URL", value);
2917: } else if (!strcasecmp(name, "ftp")) {
2918: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2919: if (distrib > 0)
2920: sql_update_id("Distribs", distrib, "URL", value);
2921: } else if (!strcasecmp(name, "ftpsrc")) {
2922: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2923: if (distrib > 0)
2924: sql_update_id("Distribs", distrib, "URLSrc", value);
1.9 veillard 2925: } else if (!strcasecmp(name, "html")) {
2926: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2927: if (distrib > 0)
2928: sql_update_id("Distribs", distrib, "Html", value);
2929: } else if (!strcasecmp(name, "color")) {
2930: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2931: if (distrib > 0)
2932: sql_update_id("Distribs", distrib, "Color", value);
1.2 veillard 2933: } else if (!strcasecmp(name, "mirror")) {
2934: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
2935: if (distrib > 0)
1.5 veillard 2936: sql_add_dist_mirror(distrib, value, 0);
1.2 veillard 2937: } else {
2938: printf("Config file : %s entry for [%s] ignored\n", name, rpmdir);
2939: }
2940: }
1.1 veillard 2941:
Webmaster