Annotation of rpm2html/sql.c, revision 1.10
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>
17: #ifdef HAVE_UNISTD_H
18: #include <unistd.h>
19: #endif
20: /********
21: #include <rpm/rpmlib.h>
22: ********/
23:
1.1 veillard 24: #include <mysql/mysql.h>
1.2 veillard 25: #include "rpm2html.h"
26: /********
27: #include "rpmdata.h"
28: ********/
1.1 veillard 29: #include "sql.h"
30:
1.8 veillard 31: #ifdef STANDALONE
32: static int rpm2htmlVerbose = 1;
33: #endif
34:
1.1 veillard 35: /************************************************************************
36: * *
37: * Generic inititialisation/close of the DB *
38: * *
39: ************************************************************************/
40:
41: static MYSQL *sql = NULL;
42:
43: int init_sql(const char *base, const char *user, const char *passwd) {
44: if (base == NULL)
45: base = "rpmfind";
46: if (passwd == NULL)
47: passwd = getenv("MySQL_PASS");
48: if (user == NULL)
49: user = getenv("MySQL_USER");
50: if (user == NULL)
51: user = getenv("USER");
52: if (user == NULL)
53: user = getenv("USERNAME");
54: if (user == NULL)
55: user = getenv("LOGNAME");
56: sql = mysql_init(NULL);
57: if (mysql_errno(sql)) {
58: fprintf(stderr, "mysql_init failed: %s\n", mysql_error(sql));
59: return(-1);
60: }
61: mysql_real_connect(sql, "localhost", user, passwd, base, 0, NULL, 0);
62: if (mysql_errno(sql)) {
63: fprintf(stderr, "mysql: connect as %s to %s failed: %s\n",
64: user, base, mysql_error(sql));
65: return(-1);
66: }
1.2 veillard 67: sql_check_tables();
1.1 veillard 68: return(0);
69: }
70:
71: int close_sql(void) {
72: mysql_close(sql);
73: if (mysql_errno(sql)) {
74: fprintf(stderr, "mysql_close failed: %s\n", mysql_error(sql));
75: return(-1);
76: }
77: return(0);
78: }
79:
80: /************************************************************************
81: * *
82: * Generic functions to access the tables *
83: * *
84: ************************************************************************/
85:
1.6 veillard 86: #define MAX_QUERY 8000
87: #define SMALL_QUERY 500
1.1 veillard 88:
89: int sql_update_id(const char *table, int id,
90: const char *field, const char *value) {
91: MYSQL_RES *result;
1.6 veillard 92: char query[MAX_QUERY];
1.1 veillard 93: int nb_fields = 0;
1.6 veillard 94: int left = MAX_QUERY - 1;
95: int len;
96: char *end;
1.1 veillard 97:
98: if ((table == NULL) ||
99: (field == NULL) || (value == NULL))
100: return(-1);
101:
1.6 veillard 102: len = snprintf(query, left, "UPDATE %s SET %s='", table, field);
103: if (len < 0) {
104: fprintf(stderr, "sql_update_id : %s(%d).%s overflow\n",
105: table, id, field);
106: return(-1);
107: }
108: end = &query[len];
109: left -= len;
110: len = strlen(value);
111: if (len * 2 >= left) {
112: fprintf(stderr, "sql_update_id : %s(%d).%s overflow\n",
113: table, id, field);
114: return(-1);
115: }
116: len = mysql_escape_string(end, value, len);
117: left -= len;
118: if (left <= 0) {
119: fprintf(stderr, "sql_update_id : %s(%d).%s overflow\n",
120: table, id, field);
121: return(-1);
122: }
123: end += len;
124: len = snprintf(end, left, "' WHERE ID=%d", id);
125: if (len < 0) {
126: fprintf(stderr, "sql_update_id : %s(%d).%s overflow\n",
127: table, id, field);
128: return(-1);
129: }
130: end += len;
131: query[MAX_QUERY - 1] = 0;
132:
133: if (mysql_real_query(sql, query, (unsigned int) (end - query))) {
1.1 veillard 134: printf("sql_update_id: UPDATE %s %d failed: %s\n",
135: table, id, mysql_error(sql));
136: return(-1);
137: }
138: result = mysql_store_result(sql);
139: if (result != NULL) {
140: nb_fields = mysql_num_fields(result);
141: mysql_free_result(result);
142: } else {
143: nb_fields = 1;
144: }
145: if(mysql_errno(sql)) {
146: fprintf(stderr, "sql_update_id UPDATE error: %s\n",
147: mysql_error(sql));
148: return(-1);
149: }
150: return(nb_fields);
151: }
152:
153: int sql_blind_insert(const char *table, const char *key,
154: const char *value, int id) {
155: MYSQL_RES *result;
1.6 veillard 156: char query[MAX_QUERY];
157: int left = MAX_QUERY - 1;
158: int len;
159: char *end;
1.8 veillard 160: int insert = -1;
1.1 veillard 161:
1.2 veillard 162: if ((table == NULL) ||
1.1 veillard 163: (key == NULL) || (value == NULL))
164: return(-1);
165:
166: /*
167: * Search first for the ID if it already exists
168: */
1.2 veillard 169: if (id > 0) {
1.6 veillard 170: len = snprintf(query, left, "INSERT INTO %s (ID, %s) VALUES (%d, '",
171: table, key, id);
172: if (len < 0) {
173: fprintf(stderr, "sql_blind_insert : %s(%d).%s overflow\n",
174: table, id, key);
175: return(-1);
176: }
177: end = &query[len];
178: left -= len;
179: len = strlen(value);
180: if (len * 2 >= left) {
181: fprintf(stderr, "sql_blind_insert : %s(%d).%s overflow\n",
182: table, id, key);
183: return(-1);
184: }
185: len = mysql_escape_string(end, value, len);
186: left -= len;
187: if (left <= 0) {
188: fprintf(stderr, "sql_blind_insert : %s(%d).%s overflow\n",
189: table, id, key);
190: return(-1);
191: }
192: end += len;
193: len = snprintf(end, left, "')");
194: if (len < 0) {
195: fprintf(stderr, "sql_blind_insert : %s(%d).%s overflow\n",
196: table, id, key);
197: return(-1);
198: }
199: end += len;
200: query[MAX_QUERY - 1] = 0;
201:
1.2 veillard 202: } else {
1.6 veillard 203: len = snprintf(query, left, "INSERT INTO %s (%s) VALUES ('",
204: table, key);
205: if (len < 0) {
206: fprintf(stderr, "sql_blind_insert : %s.%s overflow\n",
207: table, key);
208: return(-1);
209: }
210: end = &query[len];
211: left -= len;
212: len = strlen(value);
213: if (len * 2 >= left) {
214: fprintf(stderr, "sql_blind_insert : %s.%s overflow\n",
215: table, key);
216: return(-1);
217: }
218: len = mysql_escape_string(end, value, len);
219: left -= len;
220: if (left <= 0) {
221: fprintf(stderr, "sql_blind_insert : %s.%s overflow\n",
222: table, key);
223: return(-1);
224: }
225: end += len;
226: len = snprintf(end, left, "')");
227: if (len < 0) {
228: fprintf(stderr, "sql_blind_insert : %s.%s overflow\n",
229: table, key);
230: return(-1);
231: }
232: end += len;
233: query[MAX_QUERY - 1] = 0;
234:
1.2 veillard 235: }
1.6 veillard 236: query[MAX_QUERY - 1] = 0;
237: if (mysql_real_query(sql, query, (unsigned int) (end - query))) {
238: #ifdef SQL_DEBUG
239: fprintf(stderr, "sql_blind_insert Error: %s\n", mysql_error(sql));
240: #endif
1.1 veillard 241: return(-1);
242: }
243: result = mysql_store_result(sql);
1.8 veillard 244: insert = mysql_insert_id(sql);
1.1 veillard 245: if (result) {
246: mysql_free_result(result);
1.8 veillard 247: return(insert);
1.1 veillard 248: }
249: if(mysql_errno(sql)) {
250: fprintf(stderr, "sql_blind_insert Error: %s\n", mysql_error(sql));
251: return(-1);
252: }
1.8 veillard 253: return(insert);
1.1 veillard 254: }
255:
256: int sql_update(const char *table, const char *name,
257: const char *field, const char *value) {
258: MYSQL_RES *result;
259: MYSQL_ROW row;
1.6 veillard 260: char query[MAX_QUERY];
1.1 veillard 261: int id;
262: int nb_fields = 0;
1.6 veillard 263: int left = MAX_QUERY - 1;
264: int len;
265: char *end;
1.1 veillard 266:
267: if ((name == NULL) || (table == NULL) ||
268: (field == NULL) || (value == NULL))
269: return(-1);
270:
271: /*
272: * Search first for the ID if it already exists
273: */
1.6 veillard 274: snprintf(query, MAX_QUERY - 1, "SELECT ID FROM %s WHERE Name='%s'", table, name);
275: query[MAX_QUERY - 1] = 0;
1.1 veillard 276: if (mysql_query(sql,query)) {
277: printf("sql_update: SELECT failed\n");
278: return(-1);
279: }
280:
281: result = mysql_use_result(sql);
282: if (result) {
283: while((row = mysql_fetch_row(result)))
284: {
285: if (row[0] == NULL) {
286: printf("sql_update: select ID for %s returns NULL !\n", name);
287: return(-1);
288: }
289: if (sscanf(row[0], "%d", &id) != 1) {
290: printf("sql_update: ID non numeric %s\n", row[0]);
291: return(-1);
292: }
1.6 veillard 293:
294: left = MAX_QUERY - 1;
295: len = snprintf(query, left, "UPDATE %s SET %s='", table, field);
296: if (len < 0) {
297: fprintf(stderr, "sql_update : %s(%d).%s overflow\n",
298: table, id, field);
299: return(-1);
300: }
301: end = &query[len];
302: left -= len;
303: len = strlen(value);
304: if (len * 2 >= left) {
305: fprintf(stderr, "sql_update : %s(%d).%s overflow\n",
306: table, id, field);
307: return(-1);
308: }
309: len = mysql_escape_string(end, value, len);
310: left -= len;
311: if (left <= 0) {
312: fprintf(stderr, "sql_update : %s(%d).%s overflow\n",
313: table, id, field);
314: return(-1);
315: }
316: end += len;
317: len = snprintf(end, left, "' WHERE ID=%d", id);
318: if (len < 0) {
319: fprintf(stderr, "sql_update : %s(%d).%s overflow\n",
320: table, id, field);
321: return(-1);
322: }
323: end += len;
324: query[MAX_QUERY - 1] = 0;
325:
1.1 veillard 326: mysql_free_result(result);
1.6 veillard 327: if (mysql_real_query(sql, query, (unsigned int) (end - query))) {
1.2 veillard 328: printf("sql_update: UPDATE failed: %s\n", mysql_error(sql));
1.1 veillard 329: return(-1);
330: }
331: result = mysql_store_result(sql);
332: if (result != NULL) {
333: nb_fields = mysql_num_fields(result);
334: mysql_free_result(result);
335: } else {
1.2 veillard 336: return(1);
1.1 veillard 337: }
338: /* Do not loop ... only the first */
339: return(nb_fields);
340: }
341: mysql_free_result(result);
1.2 veillard 342: if (nb_fields == 0) {
343: /*
344: * Propagate an insert
345: */
1.6 veillard 346: snprintf(query, MAX_QUERY - 1,
1.2 veillard 347: "INSERT INTO %s (Name,%s) VALUES ('%s','%s')",
348: table, field, name, value);
1.6 veillard 349: query[MAX_QUERY - 1] = 0;
1.2 veillard 350: mysql_free_result(result);
351: if (mysql_query(sql, query)) {
352: printf("sql_update: INSERT failed: %s\n", mysql_error(sql));
353: return(-1);
354: }
355: result = mysql_store_result(sql);
356: if (result != NULL) {
357: nb_fields = mysql_num_fields(result);
358: mysql_free_result(result);
359: } else {
360: return(1);
361: }
362: }
1.1 veillard 363: }
364: if(mysql_errno(sql)) {
365: fprintf(stderr, "sql_update Error: %s\n", mysql_error(sql));
366: return(-1);
367: }
368: return(nb_fields);
369: }
370:
1.6 veillard 371: int sql_get_key(const char *table, const char *name, const char *value) {
1.1 veillard 372: int id;
373: MYSQL_RES *result;
374: MYSQL_ROW row;
1.6 veillard 375: char query[SMALL_QUERY];
1.1 veillard 376:
377: if ((table == NULL) || (name == NULL))
378: return(-1);
379:
380: /*
381: * Search first for the ID if it already exists
382: */
1.6 veillard 383: snprintf(query, SMALL_QUERY - 1, "SELECT ID FROM %s WHERE %s='%s'",
384: table, name, value);
385: query[SMALL_QUERY - 1] = 0;
1.1 veillard 386: if (mysql_query(sql,query)) {
387: printf("sql_create: SELECT %s failed %s\n", name, mysql_error(sql));
388: return(-1);
389: }
390:
391: result = mysql_use_result(sql);
392: if (result) {
393: while((row = mysql_fetch_row(result)))
394: {
395: /*
396: * Lookup the first ID and return it
397: */
398: if (row[0] == NULL) {
399: mysql_free_result(result);
400: printf("sql_create: select returns NULL !\n");
401: return(-1);
402: }
403: if (sscanf(row[0], "%d", &id) != 1) {
404: mysql_free_result(result);
405: printf("sql_create: ID non numeric %s\n", row[0]);
406: return(-1);
407: }
408: mysql_free_result(result);
409: return(id);
410: }
411: mysql_free_result(result);
412: }
413: if(mysql_errno(sql)) {
414: fprintf(stderr, "Error: %s\n", mysql_error(sql));
415: return(-1);
416: }
417:
418: /*
419: * Do a creation
420: */
421:
1.6 veillard 422: snprintf(query, SMALL_QUERY - 1, "INSERT INTO %s (%s) VALUES ('%s')",
423: table, name, value);
424: query[SMALL_QUERY - 1] = 0;
1.1 veillard 425: if (mysql_query(sql,query)) {
1.2 veillard 426: printf("sql_get_key: INSERT %s failed %s\n", name, mysql_error(sql));
1.1 veillard 427: return(-1);
428: }
429: id = mysql_insert_id(sql);
430: result = mysql_store_result(sql);
431: if (result != NULL)
432: mysql_free_result(result);
433: return(id);
434: }
435:
436: int sql_read_key(const char *table, const char *name) {
437: int id;
438: MYSQL_RES *result;
439: MYSQL_ROW row;
1.6 veillard 440: char query[SMALL_QUERY];
1.1 veillard 441:
442: if ((table == NULL) || (name == NULL))
443: return(-1);
444:
445: /*
446: * Search for the ID it has to exist
447: */
1.6 veillard 448: snprintf(query, SMALL_QUERY - 1, "SELECT ID FROM %s WHERE Name='%s'", table, name);
449: query[SMALL_QUERY - 1] = 0;
1.2 veillard 450: if (mysql_query(sql,query)) {
451: printf("sql_create: SELECT %s failed %s\n", name, mysql_error(sql));
452: return(-1);
453: }
454:
455: result = mysql_use_result(sql);
456: if (result) {
457: while((row = mysql_fetch_row(result)))
458: {
459: /*
460: * Lookup the first ID and return it
461: */
462: if (row[0] == NULL) {
463: mysql_free_result(result);
464: printf("sql_create: select returns NULL !\n");
465: return(-1);
466: }
467: if (sscanf(row[0], "%d", &id) != 1) {
468: mysql_free_result(result);
469: printf("sql_create: ID non numeric %s\n", row[0]);
470: return(-1);
471: }
472: mysql_free_result(result);
473: return(id);
474: }
475: mysql_free_result(result);
476: }
477: if(mysql_errno(sql)) {
478: fprintf(stderr, "Error: %s\n", mysql_error(sql));
479: return(-1);
480: }
481: return(-1);
482: }
483:
484: int sql_read_info_key(const char *table, const char *name, const char *value) {
485: int id;
486: MYSQL_RES *result;
487: MYSQL_ROW row;
1.6 veillard 488: char query[SMALL_QUERY];
1.2 veillard 489:
490: if ((table == NULL) || (name == NULL) || (value == NULL))
491: return(-1);
492:
493: /*
494: * Search for the ID it has to exist
495: */
1.6 veillard 496: snprintf(query, SMALL_QUERY - 1, "SELECT ID FROM %s WHERE %s='%s'", table, name, value);
497: query[SMALL_QUERY - 1] = 0;
1.1 veillard 498: if (mysql_query(sql,query)) {
499: printf("sql_create: SELECT %s failed %s\n", name, mysql_error(sql));
500: return(-1);
501: }
502:
503: result = mysql_use_result(sql);
504: if (result) {
505: while((row = mysql_fetch_row(result)))
506: {
507: /*
508: * Lookup the first ID and return it
509: */
510: if (row[0] == NULL) {
511: mysql_free_result(result);
512: printf("sql_create: select returns NULL !\n");
513: return(-1);
514: }
515: if (sscanf(row[0], "%d", &id) != 1) {
516: mysql_free_result(result);
517: printf("sql_create: ID non numeric %s\n", row[0]);
518: return(-1);
519: }
520: mysql_free_result(result);
521: return(id);
522: }
523: mysql_free_result(result);
524: }
525: if(mysql_errno(sql)) {
526: fprintf(stderr, "Error: %s\n", mysql_error(sql));
527: return(-1);
528: }
529: return(-1);
530: }
531:
532: /************************************************************************
533: * *
534: * Tables handling *
535: * *
536: ************************************************************************/
537:
1.2 veillard 538: int sql_rebuild_config(void) {
539: const char *query =
540: "CREATE TABLE Config ( \n\
541: ID int(11) NOT NULL auto_increment, \n\
542: Name varchar(50) NOT NULL, \n\
543: Value varchar(255), \n\
544: PRIMARY KEY (ID), \n\
545: KEY Name (Name(10)) \n\
546: )";
547:
548: if (mysql_query(sql,query)) {
549: printf("sql_rebuild_config: CREATE TABLE Config failed %s\n",
550: mysql_error(sql));
551: return(-1);
552: }
553: return(0);
554: }
555:
1.1 veillard 556: int sql_rebuild_vendors(void) {
557: const char *query =
558: "CREATE TABLE Vendors ( \n\
559: ID int(11) NOT NULL auto_increment, \n\
560: Name varchar(255) NOT NULL, \n\
561: URL varchar(255), \n\
562: Key1 text, \n\
563: Key2 text, \n\
564: Key3 text, \n\
565: Description text, \n\
566: PRIMARY KEY (ID), \n\
567: KEY Name (Name(10)) \n\
568: )";
569:
570: if (mysql_query(sql,query)) {
1.2 veillard 571: printf("sql_rebuild_vendors: CREATE TABLE Vendors failed %s\n",
1.1 veillard 572: mysql_error(sql));
573: return(-1);
574: }
575: return(0);
576: }
577:
578: int sql_rebuild_mirrors(void) {
579: const char *query =
580: "CREATE TABLE Mirrors ( \n\
581: ID int(11), \n\
582: URL varchar(255) NOT NULL, \n\
583: Country int(11), \n\
584: UNIQUE(URL) \n\
585: )";
586:
587: if (mysql_query(sql,query)) {
1.2 veillard 588: printf("sql_rebuild_mirrors: CREATE TABLE Mirrors failed %s\n",
589: mysql_error(sql));
590: return(-1);
591: }
592: return(0);
593: }
594:
595: int sql_rebuild_metadata(void) {
596: const char *query =
597: "CREATE TABLE Metadata ( \n\
598: URL varchar(255) NOT NULL, \n\
599: Maintainer int(11), \n\
600: Country int(11), \n\
601: UNIQUE(URL) \n\
602: )";
603:
604: if (mysql_query(sql,query)) {
605: printf("sql_rebuild_metadata: CREATE TABLE Metadata failed %s\n",
1.1 veillard 606: mysql_error(sql));
607: return(-1);
608: }
609: return(0);
610: }
611:
612: int sql_rebuild_distribs(void) {
613: const char *query =
614: "CREATE TABLE Distribs ( \n\
615: ID int(11) NOT NULL auto_increment, \n\
616: Name varchar(255) NOT NULL, \n\
617: Vendor int(11), \n\
1.2 veillard 618: Directory varchar(255), \n\
1.1 veillard 619: Path varchar(100) NOT NULL, \n\
620: URL varchar(255), \n\
621: URLSrc varchar(255), \n\
1.9 veillard 622: Html varchar(8), \n\
623: Color varchar(10), \n\
1.1 veillard 624: Key1 text, \n\
625: Key2 text, \n\
626: Description text, \n\
627: PRIMARY KEY (ID), \n\
628: KEY Name (Name(10)) \n\
629: )";
630:
631: if (mysql_query(sql,query)) {
1.2 veillard 632: printf("sql_rebuild_distribs: CREATE TABLE Distribs failed %s\n",
633: mysql_error(sql));
634: return(-1);
635: }
636: return(0);
637: }
638:
639: int sql_rebuild_packages(void) {
640: const char *query =
641: "CREATE TABLE Packages ( \n\
642: ID int(11) NOT NULL auto_increment, \n\
643: filename varchar(255) NOT NULL, \n\
644: Name varchar(50) NOT NULL, \n\
645: Version varchar(50) NOT NULL, \n\
646: Release varchar(50) NOT NULL, \n\
1.6 veillard 647: Arch varchar(15) NOT NULL, \n\
1.2 veillard 648: Dist int(11), \n\
649: URL varchar(255), \n\
650: URLSrc varchar(255), \n\
651: Vendor int(11), \n\
652: Packager int(11), \n\
653: Category varchar(255), \n\
654: Summary varchar(255), \n\
655: Description text, \n\
656: Copyright varchar(255), \n\
657: PRIMARY KEY (ID), \n\
1.7 veillard 658: KEY filename (filename(80)), \n\
659: KEY Name (Name(15)) \n\
1.2 veillard 660: )";
661:
662: if (mysql_query(sql,query)) {
663: printf("sql_rebuild_packages: CREATE TABLE Packages failed %s\n",
664: mysql_error(sql));
665: return(-1);
666: }
667: return(0);
668: }
669:
670: int sql_rebuild_files(void) {
671: const char *query =
672: "CREATE TABLE Files ( \n\
1.6 veillard 673: ID int(11) NOT NULL, \n\
1.7 veillard 674: Path varchar(35) NOT NULL, \n\
675: UNIQUE KEY id (ID,Path(35)), \n\
1.6 veillard 676: INDEX (ID), \n\
677: INDEX (Path) \n\
1.2 veillard 678: )";
679:
680: if (mysql_query(sql,query)) {
681: printf("sql_rebuild_files: CREATE TABLE Files failed %s\n",
1.1 veillard 682: mysql_error(sql));
683: return(-1);
684: }
685: return(0);
686: }
687:
1.8 veillard 688: int sql_rebuild_provides(void) {
689: const char *query =
690: "CREATE TABLE Provides ( \n\
691: ID int(11) NOT NULL, \n\
692: Resource varchar(35) NOT NULL, \n\
693: UNIQUE KEY id (ID,Resource(35)), \n\
694: INDEX (ID), \n\
695: INDEX (Resource) \n\
696: )";
697:
698: if (mysql_query(sql,query)) {
699: printf("sql_rebuild_files: CREATE TABLE Provides failed %s\n",
700: mysql_error(sql));
701: return(-1);
702: }
703: return(0);
704: }
705:
706: int sql_rebuild_requires(void) {
707: const char *query =
708: "CREATE TABLE Requires ( \n\
709: ID int(11) NOT NULL, \n\
710: Resource varchar(35) NOT NULL, \n\
711: Rel char(2), \n\
712: Value varchar(20), \n\
713: UNIQUE KEY id (ID,Resource(35)), \n\
714: INDEX (ID), \n\
715: INDEX (Resource) \n\
716: )";
717:
718: if (mysql_query(sql,query)) {
719: printf("sql_rebuild_files: CREATE TABLE Requires failed %s\n",
720: mysql_error(sql));
721: return(-1);
722: }
723: return(0);
724: }
725:
1.1 veillard 726:
727: int sql_check_tables(void) {
728: const char *query = "SHOW TABLES";
729: MYSQL_RES *result;
730: MYSQL_ROW row;
1.2 veillard 731: int config = 0;
1.1 veillard 732: int distribs = 0;
1.8 veillard 733: int requires = 0;
734: int provides = 0;
1.1 veillard 735: int vendors = 0;
736: int mirrors = 0;
1.2 veillard 737: int metadata = 0;
738: int packages = 0;
739: int files = 0;
740:
1.1 veillard 741: int rebuilt = 0;
742:
743: if (mysql_query(sql,query)) {
1.2 veillard 744: printf("sql_check_tables: SHOW TABLES failed %s\n",
1.1 veillard 745: mysql_error(sql));
746: return(-1);
747: }
748:
749: result = mysql_use_result(sql);
750: if (result) {
751: while((row = mysql_fetch_row(result)))
752: {
753: if (row[0] == NULL) {
754: mysql_free_result(result);
755: printf("sql_check_tables: SHOW TABLES returns NULL !\n");
756: return(-1);
757: }
1.2 veillard 758: if (!strcmp(row[0], "Config"))
759: config = 1;
1.1 veillard 760: if (!strcmp(row[0], "Distribs"))
761: distribs = 1;
762: if (!strcmp(row[0], "Vendors"))
763: vendors = 1;
764: if (!strcmp(row[0], "Mirrors"))
765: mirrors = 1;
1.2 veillard 766: if (!strcmp(row[0], "Metadata"))
767: metadata = 1;
768: if (!strcmp(row[0], "Packages"))
769: packages = 1;
770: if (!strcmp(row[0], "Files"))
771: files = 1;
1.8 veillard 772: if (!strcmp(row[0], "Requires"))
773: requires = 1;
774: if (!strcmp(row[0], "Provides"))
775: provides = 1;
1.1 veillard 776: }
777: mysql_free_result(result);
778: }
779: if(mysql_errno(sql)) {
780: fprintf(stderr, "Error: %s\n", mysql_error(sql));
781: return(-1);
782: }
783:
1.2 veillard 784: if (!config) {
785: fprintf(stderr, "Table Config disapeared: rebuilding it\n");
786: if (!sql_rebuild_config())
787: rebuilt++;
788: }
1.1 veillard 789: if (!vendors) {
790: fprintf(stderr, "Table Vendors disapeared: rebuilding it\n");
791: if (!sql_rebuild_vendors())
792: rebuilt++;
793: }
794: if (!distribs) {
795: fprintf(stderr, "Table Distribs disapeared: rebuilding it\n");
796: if (!sql_rebuild_distribs())
797: rebuilt++;
798: }
799: if (!mirrors) {
800: fprintf(stderr, "Table Mirrors disapeared: rebuilding it\n");
801: if (!sql_rebuild_mirrors())
802: rebuilt++;
803: }
1.2 veillard 804: if (!metadata) {
805: fprintf(stderr, "Table Metadata disapeared: rebuilding it\n");
806: if (!sql_rebuild_metadata())
807: rebuilt++;
808: }
809: if (!packages) {
810: fprintf(stderr, "Table Packages disapeared: rebuilding it\n");
811: if (!sql_rebuild_packages())
812: rebuilt++;
813: }
814: if (!files) {
815: fprintf(stderr, "Table Files disapeared: rebuilding it\n");
816: if (!sql_rebuild_files())
817: rebuilt++;
818: }
1.8 veillard 819: if (!requires) {
820: fprintf(stderr, "Table Requires disapeared: rebuilding it\n");
821: if (!sql_rebuild_requires())
822: rebuilt++;
823: }
824: if (!provides) {
825: fprintf(stderr, "Table Provides disapeared: rebuilding it\n");
826: if (!sql_rebuild_provides())
827: rebuilt++;
828: }
1.1 veillard 829: return(rebuilt);
830: }
831:
832: /************************************************************************
833: * *
834: * Specific rpm2html functions *
835: * *
836: ************************************************************************/
837:
1.5 veillard 838: int sql_add_dist_mirror(int distrib, const char *URL, int country) {
1.1 veillard 839: if (URL == NULL)
840: return(-1);
841: if (distrib < 0)
842: return(-1);
843: return(sql_blind_insert("Mirrors", "URL", URL, distrib));
844: }
845:
1.5 veillard 846: int sql_add_mirror(const char *Name, const char *URL, int country) {
1.1 veillard 847: int distrib;
848:
849: if ((Name == NULL) || (URL == NULL))
850: return(-1);
851: distrib = sql_read_key("Distribs", Name);
852: if (distrib < 0)
853: return(distrib);
854: return(sql_blind_insert("Mirrors", "URL", URL, distrib));
855: }
856:
1.6 veillard 857: int sql_add_file(const char *filename, int package) {
858: if ((filename == NULL) || (package <= 0))
859: return(-1);
1.7 veillard 860: if (strlen(filename) > 35)
861: return(0);
1.6 veillard 862:
863: return(sql_blind_insert("Files", "Path", filename, package));
864: }
865:
1.8 veillard 866: int sql_add_provides(int package, const char *resource) {
867: if ((resource == NULL) || (package <= 0))
868: return(-1);
869: if (strlen(resource) > 35)
870: return(0);
871:
872: return(sql_blind_insert("Provides", "Resource", resource, package));
873: }
874:
875: int sql_add_requires(int package, const char *resource, const char *rel,
876: const char *value) {
877: int record;
878: if ((resource == NULL) || (package <= 0))
879: return(-1);
880: if (strlen(resource) > 35)
881: return(0);
882:
883: record = sql_blind_insert("Requires", "Resource", resource, package);
884: if ((rel != NULL) && (value != NULL) &&
885: (strlen(rel) <= 2) && (strlen(value) <= 20)) {
886: char query[SMALL_QUERY];
887: snprintf(query, SMALL_QUERY - 1,
888: "UPDATE Requires SET Rel='%s',Value='%s' WHERE ID=%d",
889: rel, value, record);
890: query[SMALL_QUERY - 1] = 0;
891: if (mysql_query(sql,query)) {
892: printf("sql_create: UPDATE Requires %d failed %s\n",
893: record, mysql_error(sql));
894: return(record);
895: }
896: }
897: return(record);
898: }
899:
1.5 veillard 900: int sql_add_package(const char *filename,
1.2 veillard 901: const char *Name, const char *Version, const char *Release,
1.6 veillard 902: const char *Arch,
903: int dist, const char *URL, const char *URLSrc, int vendor,
1.2 veillard 904: const char *Packager, const char *Category, const char *Summary,
905: const char *Description, const char *Copyright) {
906: int id;
1.6 veillard 907: /* int packager;
908: char intStr[15]; */
1.2 veillard 909: int nb_fields = 0;
910:
1.6 veillard 911: if (filename == NULL)
1.2 veillard 912: return(-1);
1.6 veillard 913:
914: if (dist < 0)
1.2 veillard 915: return(-1);
1.6 veillard 916: if ((Name == NULL) || (Version == NULL) || (Release == NULL) ||
917: (Arch == NULL))
918: return(-1);
919:
920: id = sql_get_key("Packages", "filename", filename);
1.2 veillard 921: if (id <= 0)
922: return(-1);
923: nb_fields = 1;
1.8 veillard 924:
925: if (rpm2htmlVerbose > 1)
926: printf("Adding %s ID %d\n", filename, id);
927:
1.2 veillard 928: /*******
929: if (Packager != NULL) {
930: packager = sql_get_key("People", Packager);
931: sprintf(intStr, "%d", packager);
932: nb_fields += sql_update_id("Distribs", id, "Packager", intStr);
933: }
934: *******/
935: if (Name != NULL)
1.6 veillard 936: nb_fields += sql_update_id("Packages", id, "Name", Name);
1.2 veillard 937: if (Version != NULL)
938: nb_fields += sql_update_id("Packages", id, "Version", Version);
939: if (Release != NULL)
940: nb_fields += sql_update_id("Packages", id, "Release", Release);
1.6 veillard 941: if (Release != NULL)
942: nb_fields += sql_update_id("Packages", id, "Arch", Arch);
1.2 veillard 943: if (Category != NULL)
944: nb_fields += sql_update_id("Packages", id, "Category", Category);
945: if (URL != NULL)
946: nb_fields += sql_update_id("Packages", id, "URL", URL);
947: if (URLSrc != NULL)
948: nb_fields += sql_update_id("Packages", id, "URLSrc", URLSrc);
949: if (Summary != NULL)
950: nb_fields += sql_update_id("Packages", id, "Summary", Summary);
951: if (Description != NULL)
952: nb_fields += sql_update_id("Packages", id,
953: "Description", Description);
954: if (Copyright != NULL)
955: nb_fields += sql_update_id("Packages", id, "Copyright", Copyright);
956:
1.6 veillard 957: return(id);
1.2 veillard 958: }
959:
1.5 veillard 960: int sql_add_distrib(const char *Name, const char *Vendor,
1.2 veillard 961: const char *Directory, const char *Path, const char *URL,
1.9 veillard 962: const char *URLSrc, const char *Description,
963: const char *Html, const char *Color) {
1.1 veillard 964: int id, vendor;
965: int nb_fields = 0;
966: char VendorStr[15];
967:
968: if (Name == NULL)
969: return(-1);
970:
1.6 veillard 971: id = sql_get_key("Distribs", "Name", Name);
1.1 veillard 972: nb_fields = 1;
973: if (Vendor != NULL) {
1.6 veillard 974: vendor = sql_get_key("Vendors", "Name", Vendor);
1.1 veillard 975: sprintf(VendorStr, "%d", vendor);
976: nb_fields += sql_update_id("Distribs", id, "Vendor", VendorStr);
977: }
1.2 veillard 978: if (Directory != NULL)
979: nb_fields += sql_update_id("Distribs", id, "Directory", Directory);
1.1 veillard 980: if (Path != NULL)
981: nb_fields += sql_update_id("Distribs", id, "Path", Path);
982: if (URL != NULL)
983: nb_fields += sql_update_id("Distribs", id, "URL", URL);
984: if (URLSrc != NULL)
985: nb_fields += sql_update_id("Distribs", id, "URLSrc", URLSrc);
1.9 veillard 986: if (Html != NULL)
987: nb_fields += sql_update_id("Distribs", id, "Html", Html);
988: if (Color != NULL)
989: nb_fields += sql_update_id("Distribs", id, "Color", Color);
1.1 veillard 990: if (Description != NULL)
991: nb_fields += sql_update_id("Distribs", id,
992: "Description", Description);
993:
994: return(nb_fields);
995: }
996:
1.5 veillard 997: int sql_add_vendor(const char *Name, const char *URL, const char *Description) {
1.1 veillard 998: int id;
999: int nb_fields = 0;
1000:
1001: if (Name == NULL)
1002: return(-1);
1003:
1.6 veillard 1004: id = sql_get_key("Vendors", "Name", Name);
1.1 veillard 1005: nb_fields = 1;
1006: if (URL != NULL)
1007: nb_fields += sql_update_id("Vendors", id, "URL", URL);
1008: if (Description != NULL)
1009: nb_fields += sql_update_id("Vendors", id,
1010: "Description", Description);
1011:
1012: return(nb_fields);
1013: }
1014:
1.5 veillard 1015: void sql_add_config_info(const char *name, const char *value) {
1.2 veillard 1016: sql_update("Config", name, "Value", value);
1017: }
1018:
1.5 veillard 1019: void sql_add_metadata_base(const char *URL) {
1.2 veillard 1020: sql_blind_insert("Metadata", "URL", URL, -1);
1021: }
1022:
1.6 veillard 1023: /************************************************************************
1024: * *
1.8 veillard 1025: * Cleanup functions *
1026: * *
1027: ************************************************************************/
1028:
1029: int sql_remove_package(int id) {
1030: char query[SMALL_QUERY];
1031:
1032: if (id <= 0)
1033: return(-1);
1034:
1035: /*
1036: * remove the ID from the package list
1037: */
1038: snprintf(query, SMALL_QUERY - 1, "DELETE FROM Packages WHERE ID=%d", id);
1039: query[SMALL_QUERY - 1] = 0;
1040: if (mysql_query(sql,query)) {
1041: printf("sql_create: DELETE package %d failed %s\n", id, mysql_error(sql));
1042: return(-1);
1043: }
1044: if(mysql_errno(sql)) {
1045: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1046: return(-1);
1047: }
1048:
1049: /*
1050: * remove the associated files from the Files list
1051: */
1052: snprintf(query, SMALL_QUERY - 1, "DELETE FROM Files WHERE ID=%d", id);
1053: query[SMALL_QUERY - 1] = 0;
1054: if (mysql_query(sql,query)) {
1055: printf("sql_create: DELETE Files %d failed %s\n", id, mysql_error(sql));
1056: return(-1);
1057: }
1058: if(mysql_errno(sql)) {
1059: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1060: return(-1);
1061: }
1062:
1063: /*
1064: * remove the associated Provides entries
1065: */
1066: snprintf(query, SMALL_QUERY - 1, "DELETE FROM Provides WHERE ID=%d", id);
1067: query[SMALL_QUERY - 1] = 0;
1068: if (mysql_query(sql,query)) {
1069: printf("sql_create: DELETE Provides %d failed %s\n", id, mysql_error(sql));
1070: return(-1);
1071: }
1072: if(mysql_errno(sql)) {
1073: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1074: return(-1);
1075: }
1076:
1077: /*
1078: * remove the associated Requires entries
1079: */
1080: snprintf(query, SMALL_QUERY - 1, "DELETE FROM Requires WHERE ID=%d", id);
1081: query[SMALL_QUERY - 1] = 0;
1082: if (mysql_query(sql,query)) {
1083: printf("sql_create: DELETE Requires %d failed %s\n", id, mysql_error(sql));
1084: return(-1);
1085: }
1086: if(mysql_errno(sql)) {
1087: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1088: return(-1);
1089: }
1090:
1091: return(-1);
1092: }
1093:
1094: int sql_check_packages(void) {
1095: MYSQL_RES *result;
1096: MYSQL_ROW row;
1097: char *query = "SELECT filename,ID FROM Packages LIMIT 500";
1098: struct stat buf;
1099: int id;
1100: int ids[500];
1101: int index;
1102: int total = 0;
1103:
1104: if (rpm2htmlVerbose)
1105: printf("Database cleanup\n");
1106: rescan:
1107: index = 0;
1108: /*
1109: * Search first for the ID if it already exists
1110: */
1111: if (mysql_query(sql,query)) {
1112: printf("sql_check_packages: SELECT from Packages failed: %s\n",
1113: mysql_error(sql));
1114: return(-1);
1115: }
1116:
1117: result = mysql_use_result(sql);
1118: if (result) {
1119: while((row = mysql_fetch_row(result)))
1120: {
1121: if ((row[0] == NULL) || (row[1] == NULL)) {
1122: printf("sql_check_packages: Path or ID is NULL !\n");
1123: continue;
1124: }
1125: if ((stat(row[0], &buf) < 0) || (buf.st_size < 50)) {
1126: /*
1127: * Need to remove the package from the database.
1128: */
1129: if (sscanf(row[1], "%d", &id) != 1) {
1130: printf("sql_check_packages: ID non numeric %s\n", row[1]);
1131: continue;
1132: }
1133: ids[index++] = id;
1134: if (rpm2htmlVerbose > 1)
1135: printf("Removing %s ID %d\n", row[0], id);
1136: if (index >= 500)
1137: break;
1138: }
1139: }
1140: mysql_free_result(result);
1141: }
1142: if(mysql_errno(sql)) {
1143: fprintf(stderr, "sql_update Error: %s\n", mysql_error(sql));
1144: return(-1);
1145: }
1146:
1147: /*
1148: * Do the cleanup.
1149: */
1150: for (id = 0;id < index;id++) {
1151: sql_remove_package(ids[id]);
1152: }
1153:
1154: total += index;
1155: if (index >= 500)
1156: goto rescan;
1157: if (rpm2htmlVerbose)
1158: printf("Database cleanup : removed %d entries\n", total);
1159: return(total);
1160: }
1161:
1162: /************************************************************************
1163: * *
1.6 veillard 1164: * Export functions *
1165: * *
1166: ************************************************************************/
1167:
1168: void sql_show_config(void) {
1169: MYSQL_RES *result;
1170: MYSQL_ROW row;
1.8 veillard 1171: int id, i;
1172: int index = 0;
1173: int ids[500];
1174: char query[SMALL_QUERY];
1.6 veillard 1175:
1176:
1.8 veillard 1177: printf(";\n; Configuration file for rpm2html\n");
1178: printf("; http://rpmfind.net/linux/rpm2html/\n;\n\n");
1179: mysql_query(sql,"SELECT Name,Value FROM Config");
1.6 veillard 1180: result = mysql_use_result(sql);
1181:
1182: while((row = mysql_fetch_row(result)))
1183: {
1.8 veillard 1184: if (row[0] == NULL) {
1185: printf("\n");
1186: } else {
1187: if (!strcmp(row[0], "maint"))
1188: printf("; maintainer of the local rpm mirror\n");
1189: else if (!strcmp(row[0], "mail"))
1190: printf("; mail for the maintainer\n");
1191: else if (!strcmp(row[0], "dir"))
1192: printf("; Directory to store the HTML pages produced\n");
1193: else if (!strcmp(row[0], "url"))
1194: printf("; The relative URL for front pages\n");
1195: else if (!strcmp(row[0], "header"))
1196: printf("; Extra link in the navigation bar\n");
1197: else if (!strcmp(row[0], "html"))
1198: printf("; Export the local packages in HTML format\n");
1199: else if (!strcmp(row[0], "tree"))
1200: printf("; Build the tree for the distributions\n");
1201: else if (!strcmp(row[0], "rdf"))
1202: printf("; Export the local packages in RDF format\n");
1203: else if (!strcmp(row[0], "rdf_dir"))
1204: printf("; Directory to store the RDf tree\n");
1205: else if (!strcmp(row[0], "rdf_resources"))
1206: printf("; Compile a list of resources in RDF format\n");
1207: else if (!strcmp(row[0], "rdf_resources_dir"))
1208: printf("; Directory to store the RDf resources tree\n");
1209:
1.6 veillard 1210: if (row[1] == NULL)
1.8 veillard 1211: printf("%s\n\n", row[0]);
1.6 veillard 1212: else
1.8 veillard 1213: printf("%s=%s\n\n", row[0], row[1]);
1214: }
1215: }
1216: mysql_free_result(result);
1217: if(mysql_errno(sql)) {
1218: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1219: }
1220:
1221: /*
1222: * Dump the Metadata
1223: */
1224: printf(";\n; The metadata mirrors list\n;\n\n[metadata]\n");
1225: mysql_query(sql,"SELECT URL FROM Metadata");
1226: result = mysql_use_result(sql);
1227:
1228: while((row = mysql_fetch_row(result)))
1229: {
1230: if (row[0] != NULL) {
1231: printf("mirror=%s\n", row[0]);
1.6 veillard 1232: }
1233: }
1.8 veillard 1234: mysql_free_result(result);
1.6 veillard 1235: if(mysql_errno(sql)) {
1236: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1237: }
1238:
1.8 veillard 1239: /*
1240: * Dump the distributions informations
1241: * 1/ collect the list of IDs for the distribs
1242: */
1243: printf("\n\n;\n; The distribution list\n;\n\n");
1244: mysql_query(sql,"SELECT ID FROM Distribs");
1245: result = mysql_use_result(sql);
1246:
1247: while((row = mysql_fetch_row(result)))
1248: {
1249: if (row[0] != NULL) {
1250: if (sscanf(row[0], "%d", &id) == 1) {
1251: ids[index++] = id;
1252: }
1253: }
1254: }
1255: mysql_free_result(result);
1256:
1257: /*
1258: * Dump each distribution separately.
1259: */
1260: for (i = 0;i < index;i++) {
1261:
1262: snprintf(query, SMALL_QUERY - 1,
1.10 ! veillard 1263: "SELECT Directory,Name,Vendor,Path,URL,URLSrc,Description,Html,Color \
1.8 veillard 1264: FROM Distribs WHERE ID=%d", ids[i]);
1265: query[SMALL_QUERY - 1] = 0;
1266: if (mysql_query(sql,query)) {
1267: printf("sql_show_config: SELECT Distrib %d failed: %s\n",
1268: ids[i], mysql_error(sql));
1269: continue;
1270: }
1271:
1272: result = mysql_use_result(sql);
1273: if (result) {
1274: while((row = mysql_fetch_row(result)))
1275: {
1276: if (row[0] == NULL)
1277: break;
1278: printf("[%s]\n", row[0]);
1279: if (row[1] != NULL)
1280: printf("name=%s\n", row[1]);
1281: if (row[3] != NULL)
1282: printf("subdir=%s\n", row[3]);
1283: if (row[4] != NULL)
1284: printf("ftp=%s\n", row[4]);
1285: if (row[5] != NULL)
1286: printf("ftpsrc=%s\n", row[5]);
1.10 ! veillard 1287: if (row[7] != NULL)
! 1288: printf("html=%s\n", row[7]);
! 1289: if (row[8] != NULL)
! 1290: printf("color=%s\n", row[8]);
1.8 veillard 1291: }
1292: }
1293: mysql_free_result(result);
1294: printf("\n\n");
1295: }
1296:
1297: printf(";\n; End of the configuration file for rpm2html\n;\n");
1.6 veillard 1298: }
1299:
1300: void sql_show_metadata(void) {
1301: MYSQL_RES *result;
1302: MYSQL_ROW row;
1303:
1304:
1305: mysql_query(sql,"SELECT URL FROM Metadata");
1306: result = mysql_use_result(sql);
1307:
1308: while((row = mysql_fetch_row(result)))
1309: {
1310: if (row[0] == NULL)
1311: printf("NULL !\n");
1312: else {
1313: printf("%s\n", row[0]);
1314: }
1315: }
1316: if(mysql_errno(sql)) {
1317: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1318: }
1319:
1320: }
1321:
1322: void sql_show_mirrors(void) {
1323: MYSQL_RES *result;
1324: MYSQL_ROW row;
1325:
1326:
1327: mysql_query(sql,"SELECT URL FROM Mirrors");
1328: result = mysql_use_result(sql);
1329:
1330: while((row = mysql_fetch_row(result)))
1331: {
1332: if (row[0] == NULL)
1333: printf("NULL !\n");
1334: else {
1335: printf("%s\n", row[0]);
1336: }
1337: }
1338: if(mysql_errno(sql)) {
1339: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1340: }
1341: }
1342:
1.5 veillard 1343: void sql_show_vendors(void) {
1.1 veillard 1344: MYSQL_RES *result;
1345: MYSQL_ROW row;
1346:
1347:
1348: mysql_query(sql,"SELECT Name, URL FROM Vendors");
1349: result = mysql_use_result(sql);
1350:
1351: while((row = mysql_fetch_row(result)))
1352: {
1353: if (row[0] == NULL)
1354: printf("NULL !\n");
1355: else {
1356: if (row[1] == NULL)
1357: printf("%s : no url\n", row[0]);
1358: else
1359: printf("%s : %s\n", row[0], row[1]);
1360: }
1361: }
1362: if(mysql_errno(sql)) {
1363: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1364: }
1365:
1366: }
1367:
1.5 veillard 1368: void sql_show_distribs(void) {
1.1 veillard 1369: MYSQL_RES *result;
1370: MYSQL_ROW row;
1371:
1372:
1373: mysql_query(sql,"SELECT Name, Path, URL FROM Distribs");
1374: result = mysql_use_result(sql);
1375:
1376: while((row = mysql_fetch_row(result)))
1377: {
1378: if (row[0] == NULL)
1379: printf("NULL !\n");
1380: else {
1381: if (row[1] == NULL)
1382: printf("%s : no Path\n", row[0]);
1383: else {
1384: if (row[2] == NULL)
1385: printf("%s : %s : no url\n", row[0], row[1]);
1386: else
1387: printf("%s : %s : %s\n", row[0], row[1], row[2]);
1388: }
1389: }
1390: }
1391: if(mysql_errno(sql)) {
1392: fprintf(stderr, "Error: %s\n", mysql_error(sql));
1393: }
1394:
1395: }
1396:
1.5 veillard 1397: int sql_show_table_stats(const char *table, const char *key) {
1.6 veillard 1398: char query[MAX_QUERY];
1.2 veillard 1399: MYSQL_RES *result;
1400: MYSQL_ROW row;
1401: int res;
1402:
1403: /*
1404: * Search first for the ID if it already exists
1405: */
1.6 veillard 1406: snprintf(query, MAX_QUERY - 1, "SELECT COUNT(%s) FROM %s", key, table);
1407: query[MAX_QUERY - 1] = 0;
1.2 veillard 1408: if (mysql_query(sql,query)) {
1.5 veillard 1409: printf("sql_show_table_stats: SELECT COUNT failed: %s\n",
1.2 veillard 1410: mysql_error(sql));
1411: return(-1);
1412: }
1413:
1414: result = mysql_use_result(sql);
1415: if (result) {
1416: while((row = mysql_fetch_row(result)))
1417: {
1418: /*
1419: * Lookup the value and return it
1420: */
1421: if (row[0] == NULL) {
1422: mysql_free_result(result);
1.5 veillard 1423: printf("sql_show_table_stats: select count returns NULL !\n");
1.2 veillard 1424: return(-1);
1425: }
1426: if (sscanf(row[0], "%d", &res) != 1) {
1427: mysql_free_result(result);
1.5 veillard 1428: printf("sql_show_table_stats: value non numeric %s\n", row[0]);
1.2 veillard 1429: return(-1);
1430: }
1431: mysql_free_result(result);
1432: if (res <= 0)
1433: printf(" %s is empty\n", table);
1434: else
1435: printf(" %s contains %d records\n", table, res);
1436: return(res);
1437: }
1438: mysql_free_result(result);
1439: }
1440: if(mysql_errno(sql)) {
1.5 veillard 1441: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.2 veillard 1442: }
1443: return(-1);
1444: }
1445:
1.5 veillard 1446: int sql_show_stats(void) {
1.2 veillard 1447: const char *query = "SHOW TABLES";
1448: MYSQL_RES *result;
1449: MYSQL_ROW row;
1450:
1451: int tables = 0;
1452: int records = 0;
1453:
1454: if (mysql_query(sql,query)) {
1455: printf("sql_check_tables: SHOW TABLES failed %s\n",
1456: mysql_error(sql));
1457: return(-1);
1458: }
1459:
1460: result = mysql_use_result(sql);
1461: if (result) {
1462: while((row = mysql_fetch_row(result)))
1463: {
1464: if (row[0] == NULL) {
1465: mysql_free_result(result);
1466: printf("sql_check_tables: SHOW TABLES returns NULL !\n");
1467: return(-1);
1468: }
1469: tables++;
1470: }
1471: mysql_free_result(result);
1472: }
1473: if(mysql_errno(sql)) {
1.5 veillard 1474: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.2 veillard 1475: }
1476: printf("%d tables in use\n", tables);
1.5 veillard 1477: records += sql_show_table_stats("Config", "Name");
1478: records += sql_show_table_stats("Distribs", "Name");
1479: records += sql_show_table_stats("Vendors", "Name");
1480: records += sql_show_table_stats("Mirrors", "URL");
1481: records += sql_show_table_stats("Metadata", "URL");
1482: records += sql_show_table_stats("Packages", "Name");
1.8 veillard 1483: records += sql_show_table_stats("Requires", "Resource");
1484: records += sql_show_table_stats("Provides", "Resource");
1.5 veillard 1485: records += sql_show_table_stats("Files", "Path");
1.2 veillard 1486: printf("Total: %d records\n", records);
1487: return(records);
1488: }
1489:
1490: /************************************************************************
1491: * *
1492: * rpm2html configuration functions *
1493: * *
1494: ************************************************************************/
1495: #ifndef STANDALONE
1496:
1497: int readConfigSql(void) {
1.6 veillard 1498: char query[MAX_QUERY];
1.3 veillard 1499: MYSQL_RES *result;
1500: MYSQL_ROW row;
1.4 veillard 1501: int dir = 0;
1.3 veillard 1502:
1.2 veillard 1503: /*
1.3 veillard 1504: * General configuration informations
1.2 veillard 1505: */
1.6 veillard 1506: snprintf(query, MAX_QUERY - 1, "SELECT Name,Value FROM Config");
1507: query[MAX_QUERY - 1] = 0;
1.3 veillard 1508: if (mysql_query(sql,query)) {
1509: printf("sql_check_tables: SELECT Config failed %s\n",
1510: mysql_error(sql));
1511: return(-1);
1512: }
1513:
1514: result = mysql_use_result(sql);
1515: if (result) {
1516: while((row = mysql_fetch_row(result)))
1517: {
1518: if ((row[0] == NULL) || (row[1] == NULL)) {
1519: fprintf(stderr, "readConfigSql : found NULL value\n");
1520: continue;
1521: }
1.4 veillard 1522: if (!strcmp(row[0], "dir"))
1523: dir = 1;
1.3 veillard 1524: addConfigEntry(RPM2HTML_NAME, row[0], row[1]);
1525: }
1526: mysql_free_result(result);
1527: }
1528: if(mysql_errno(sql)) {
1.5 veillard 1529: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.4 veillard 1530: }
1531: if (dir == 0) {
1532: fprintf(stderr, "readConfigSql : no directory\n");
1533: return(-1);
1.3 veillard 1534: }
1535:
1536: /*
1537: * The metadata mirror list.
1538: */
1.6 veillard 1539: snprintf(query, MAX_QUERY - 1, "SELECT URL FROM Metadata");
1540: query[MAX_QUERY - 1] = 0;
1.3 veillard 1541: if (mysql_query(sql,query)) {
1542: printf("sql_check_tables: SELECT Metadata failed %s\n",
1543: mysql_error(sql));
1544: return(-1);
1545: }
1546:
1547: result = mysql_use_result(sql);
1548: if (result) {
1549: while((row = mysql_fetch_row(result)))
1550: {
1551: if (row[0] == NULL) {
1552: fprintf(stderr, "readConfigSql : found NULL metadata\n");
1553: continue;
1554: }
1555: addConfigEntry("metadata", "mirror", row[0]);
1556: }
1557: mysql_free_result(result);
1558: }
1559: if(mysql_errno(sql)) {
1.5 veillard 1560: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 1561: }
1562:
1563: /*
1564: * The distribution lists
1565: */
1.6 veillard 1566: snprintf(query, MAX_QUERY - 1, "SELECT Directory,Name,URL,URLSrc,Path FROM Distribs");
1567: query[MAX_QUERY - 1] = 0;
1.3 veillard 1568: if (mysql_query(sql,query)) {
1569: printf("sql_check_tables: SELECT Distribs failed %s\n",
1570: mysql_error(sql));
1571: return(-1);
1572: }
1573:
1574: result = mysql_use_result(sql);
1575: if (result) {
1576: while((row = mysql_fetch_row(result)))
1577: {
1578: if (row[0] == NULL) {
1579: fprintf(stderr, "readConfigSql : found NULL distro\n");
1580: continue;
1581: }
1582:
1583: if (row[1] != NULL)
1584: addConfigEntry(row[0], "name", row[1]);
1585: if (row[2] != NULL)
1586: addConfigEntry(row[0], "ftp", row[2]);
1587: if (row[3] != NULL)
1588: addConfigEntry(row[0], "ftp", row[3]);
1589: if (row[4] != NULL)
1590: addConfigEntry(row[0], "subdir", row[4]);
1591: }
1592: mysql_free_result(result);
1593: }
1594: if(mysql_errno(sql)) {
1.5 veillard 1595: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 1596: }
1597:
1598: /*
1599: * The Mirrors
1600: */
1.6 veillard 1601: snprintf(query, MAX_QUERY - 1, "SELECT Distribs.Directory,Mirrors.URL FROM Distribs,Mirrors WHERE Distribs.ID = Mirrors.ID");
1602: query[MAX_QUERY - 1] = 0;
1.3 veillard 1603: if (mysql_query(sql,query)) {
1604: printf("sql_check_tables: SELECT Distribs failed %s\n",
1605: mysql_error(sql));
1606: return(-1);
1607: }
1608:
1609: result = mysql_use_result(sql);
1610: if (result) {
1611: while((row = mysql_fetch_row(result)))
1612: {
1613: if ((row[0] == NULL) || (row[1] == NULL)) {
1614: fprintf(stderr, "readConfigSql : found NULL mirror\n");
1615: continue;
1616: }
1617:
1618: addConfigEntry(row[0], "mirror", row[1]);
1619: }
1620: mysql_free_result(result);
1621: }
1622: if(mysql_errno(sql)) {
1.5 veillard 1623: fprintf(stderr, "sql_show_stats error: %s\n", mysql_error(sql));
1.3 veillard 1624: }
1625:
1.5 veillard 1626: /*
1627: * TODO: add the language(s) stuff
1628: */
1.3 veillard 1629: return(0);
1.2 veillard 1630: }
1631:
1632: void sqlConfigEntry(const char *rpmdir, const char *name, const char *value) {
1633: int distrib;
1634:
1635: if (rpm2htmlVerbose > 1)
1636: printf("sqlConfigEntry(\"%s\", \"%s\", \"%s\")\n", rpmdir, name, value);
1637:
1638: /*
1639: * case of global option for rpm2html.
1640: */
1641: if (!strcasecmp(rpmdir, RPM2HTML_NAME)) {
1.5 veillard 1642: sql_add_config_info(name, value);
1.2 veillard 1643: return;
1644: }
1645:
1646: /*
1647: * Options for the metadata mirrors.
1648: */
1649: if (!strcasecmp(rpmdir, "metadata")) {
1650: if (!strcasecmp(name, "mirror")) {
1.5 veillard 1651: sql_add_metadata_base(value);
1.2 veillard 1652: } else {
1653: printf("Config file : %s entry for [metadata] ignored\n", name);
1654: }
1655: return;
1656: }
1657:
1658: /*
1659: * option for a directory.
1660: */
1661: if (!strcasecmp(name, "name")) {
1.9 veillard 1662: sql_add_distrib(value, NULL, rpmdir, NULL, NULL, NULL, NULL,
1663: NULL, NULL);
1.2 veillard 1664: } else if (!strcasecmp(name, "subdir")) {
1665: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
1666: if (distrib > 0)
1667: sql_update_id("Distribs", distrib, "Path", value);
1668: } else if (!strcasecmp(name, "url")) {
1669: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
1670: if (distrib > 0)
1671: sql_update_id("Distribs", distrib, "URL", value);
1672: } else if (!strcasecmp(name, "ftp")) {
1673: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
1674: if (distrib > 0)
1675: sql_update_id("Distribs", distrib, "URL", value);
1676: } else if (!strcasecmp(name, "ftpsrc")) {
1677: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
1678: if (distrib > 0)
1679: sql_update_id("Distribs", distrib, "URLSrc", value);
1.9 veillard 1680: } else if (!strcasecmp(name, "html")) {
1681: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
1682: if (distrib > 0)
1683: sql_update_id("Distribs", distrib, "Html", value);
1684: } else if (!strcasecmp(name, "color")) {
1685: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
1686: if (distrib > 0)
1687: sql_update_id("Distribs", distrib, "Color", value);
1.2 veillard 1688: } else if (!strcasecmp(name, "mirror")) {
1689: distrib = sql_read_info_key("Distribs", "Directory", rpmdir);
1690: if (distrib > 0)
1.5 veillard 1691: sql_add_dist_mirror(distrib, value, 0);
1.2 veillard 1692: } else {
1693: printf("Config file : %s entry for [%s] ignored\n", name, rpmdir);
1694: }
1695: }
1696: #endif
1697:
1698: /************************************************************************
1699: * *
1700: * Main part when compiled standalone *
1701: * *
1702: ************************************************************************/
1703:
1.1 veillard 1704: #ifdef STANDALONE
1705: void usage(const char *name) {
1706: printf("%s: usage\n", name);
1.6 veillard 1707: printf(" stats: show database usage statistics\n");
1.8 veillard 1708: printf(" stats: show database usage statistics\n");
1709: printf(" check: remove superfluous entries from the database\n");
1.1 veillard 1710: printf(" vendors: list the registered vendors\n");
1711: printf(" distribs: list the registered distribs\n");
1.6 veillard 1712: printf(" metadata: list the registered metadata servers\n");
1713: printf(" mirrors: list the registered mirrors\n");
1.2 veillard 1714: printf(" add distrib name [vendor [directory [path [url [ urlsrc [description]]]]]]\n");
1.1 veillard 1715: printf(" add vendor name [url [description]]\n");
1716: printf(" add mirror distrib url\n");
1717: exit(1);
1718: }
1719:
1720: int main(int argc, char **argv) {
1721: int res;
1722:
1723: if (argc < 2)
1724: usage(argv[0]);
1725:
1726: if (init_sql(NULL, NULL, NULL) < 0)
1727: exit(1);
1728:
1729: res = sql_check_tables();
1730: if (res > 0) {
1731: printf("rebuilt %d tables\n", res);
1732: }
1733:
1734: if (!strcmp(argv[1], "vendors"))
1.5 veillard 1735: sql_show_vendors();
1.6 veillard 1736: else if (!strcmp(argv[1], "metadata"))
1737: sql_show_metadata();
1738: else if (!strcmp(argv[1], "mirrors"))
1739: sql_show_mirrors();
1.1 veillard 1740: else if (!strcmp(argv[1], "distribs"))
1.5 veillard 1741: sql_show_distribs();
1.6 veillard 1742: else if (!strcmp(argv[1], "config"))
1743: sql_show_config();
1.2 veillard 1744: else if (!strcmp(argv[1], "stats"))
1.5 veillard 1745: sql_show_stats();
1.8 veillard 1746: else if (!strcmp(argv[1], "check"))
1747: sql_check_packages();
1.1 veillard 1748: else if (!strcmp(argv[1], "add")) {
1749: if (argc < 5)
1750: usage(argv[0]);
1751: if (!strcmp(argv[2], "distrib")) {
1752: char *Name = NULL;
1753: char *Path = NULL;
1.2 veillard 1754: char *Directory = NULL;
1.1 veillard 1755: char *Vendor = NULL;
1756: char *URL = NULL;
1757: char *URLSrc = NULL;
1758: char *Description = NULL;
1.9 veillard 1759: char *Color = NULL;
1760: char *Html = NULL;
1.1 veillard 1761: if ((argc > 3) && (argv[3][0] != 0))
1762: Name = argv[3];
1763: if ((argc > 4) && (argv[4][0] != 0))
1764: Vendor = argv[4];
1765: if ((argc > 5) && (argv[5][0] != 0))
1.2 veillard 1766: Directory = argv[5];
1.1 veillard 1767: if ((argc > 6) && (argv[6][0] != 0))
1.2 veillard 1768: Path = argv[6];
1.1 veillard 1769: if ((argc > 7) && (argv[7][0] != 0))
1.2 veillard 1770: URL = argv[7];
1.1 veillard 1771: if ((argc > 8) && (argv[8][0] != 0))
1.2 veillard 1772: URLSrc = argv[8];
1773: if ((argc > 9) && (argv[9][0] != 0))
1774: Description = argv[9];
1.5 veillard 1775: res = sql_add_distrib(Name, Vendor, Directory, Path,
1.9 veillard 1776: URL, URLSrc, Description, Color, Html);
1.1 veillard 1777: printf("updated %d fields\n", res);
1778: } else if (!strcmp(argv[2], "vendor")) {
1779: char *Name = NULL;
1780: char *URL = NULL;
1781: char *Description = NULL;
1782: if ((argc > 3) && (argv[3][0] != 0))
1783: Name = argv[3];
1784: if ((argc > 4) && (argv[4][0] != 0))
1785: URL = argv[4];
1786: if ((argc > 5) && (argv[5][0] != 0))
1787: Description = argv[5];
1.5 veillard 1788: res = sql_add_vendor(Name, URL, Description);
1.1 veillard 1789: printf("updated %d fields\n", res);
1790: } else if (!strcmp(argv[2], "mirror")) {
1791: char *Name = NULL;
1792: char *URL = NULL;
1793: if ((argc > 3) && (argv[3][0] != 0))
1794: Name = argv[3];
1795: if ((argc > 4) && (argv[4][0] != 0))
1796: URL = argv[4];
1.5 veillard 1797: res = sql_add_mirror(Name, URL, 0);
1.1 veillard 1798: printf("updated %d fields\n", res);
1799: }
1800: }
1801:
1802: if (close_sql() < 0)
1803: return(1);
1804: exit(0);
1805: }
1806:
1807: #endif
Webmaster