Main Page   Modules   Data Structures   File List   Data Fields   Globals   Related Pages  

lib/header_internal.c

Go to the documentation of this file.
00001 
00005 #include "system.h"
00006 
00007 #include <header_internal.h>
00008 
00009 #include "debug.h"
00010 
00011 char ** headerGetLangs(Header h)
00012 {
00013     char **s, *e, **table;
00014     int i, type, count;
00015 
00016     if (!headerGetRawEntry(h, HEADER_I18NTABLE, &type, (const void **)&s, &count))
00017         return NULL;
00018 
00019     /* XXX xcalloc never returns NULL. */
00020     if ((table = (char **)xcalloc((count+1), sizeof(char *))) == NULL)
00021         return NULL;
00022 
00023     for (i = 0, e = *s; i < count > 0; i++, e += strlen(e)+1)
00024         table[i] = e;
00025     table[count] = NULL;
00026 
00027     /*@-nullret@*/ return table; /*@=nullret@*/ /* LCL: double indirection? */
00028 }
00029 
00030 void headerDump(Header h, FILE *f, int flags,
00031         const struct headerTagTableEntry_s * tags)
00032 {
00033     int i;
00034     indexEntry p;
00035     const struct headerTagTableEntry_s * tage;
00036     const char * tag;
00037     char * type;
00038 
00039     /* First write out the length of the index (count of index entries) */
00040     fprintf(f, "Entry count: %d\n", h->indexUsed);
00041 
00042     /* Now write the index */
00043     p = h->index;
00044     fprintf(f, "\n             CT  TAG                  TYPE         "
00045                 "      OFSET      COUNT\n");
00046     for (i = 0; i < h->indexUsed; i++) {
00047         switch (p->info.type) {
00048         case RPM_NULL_TYPE:             type = "NULL";  break;
00049         case RPM_CHAR_TYPE:             type = "CHAR";  break;
00050         case RPM_BIN_TYPE:              type = "BIN";   break;
00051         case RPM_INT8_TYPE:             type = "INT8";  break;
00052         case RPM_INT16_TYPE:            type = "INT16";         break;
00053         case RPM_INT32_TYPE:            type = "INT32";         break;
00054         /*case RPM_INT64_TYPE:          type = "INT64";         break;*/
00055         case RPM_STRING_TYPE:           type = "STRING";        break;
00056         case RPM_STRING_ARRAY_TYPE:     type = "STRING_ARRAY"; break;
00057         case RPM_I18NSTRING_TYPE:       type = "I18N_STRING"; break;
00058         default:                        type = "(unknown)";     break;
00059         }
00060 
00061         tage = tags;
00062         while (tage->name && tage->val != p->info.tag) tage++;
00063 
00064         if (!tage->name)
00065             tag = "(unknown)";
00066         else
00067             tag = tage->name;
00068 
00069         fprintf(f, "Entry      : %3.3d (%d)%-14s %-18s 0x%.8x %.8d\n", i,
00070                 p->info.tag, tag, type, (unsigned) p->info.offset,
00071                 (int) p->info.count);
00072 
00073         if (flags & HEADER_DUMP_INLINE) {
00074             char *dp = p->data;
00075             int c = p->info.count;
00076             int ct = 0;
00077 
00078             /* Print the data inline */
00079             switch (p->info.type) {
00080             case RPM_INT32_TYPE:
00081                 while (c--) {
00082                     fprintf(f, "       Data: %.3d 0x%08x (%d)\n", ct++,
00083                             (unsigned) *((int_32 *) dp),
00084                             (int) *((int_32 *) dp));
00085                     dp += sizeof(int_32);
00086                 }
00087                 break;
00088 
00089             case RPM_INT16_TYPE:
00090                 while (c--) {
00091                     fprintf(f, "       Data: %.3d 0x%04x (%d)\n", ct++,
00092                             (unsigned) (*((int_16 *) dp) & 0xffff),
00093                             (int) *((int_16 *) dp));
00094                     dp += sizeof(int_16);
00095                 }
00096                 break;
00097             case RPM_INT8_TYPE:
00098                 while (c--) {
00099                     fprintf(f, "       Data: %.3d 0x%02x (%d)\n", ct++,
00100                             (unsigned) (*((int_8 *) dp) & 0xff),
00101                             (int) *((int_8 *) dp));
00102                     dp += sizeof(int_8);
00103                 }
00104                 break;
00105             case RPM_BIN_TYPE:
00106                 while (c > 0) {
00107                     fprintf(f, "       Data: %.3d ", ct);
00108                     while (c--) {
00109                         fprintf(f, "%02x ", (unsigned) (*(int_8 *)dp & 0xff));
00110                         ct++;
00111                         dp += sizeof(int_8);
00112                         if (! (ct % 8)) {
00113                             /*@loopbreak@*/ break;
00114                         }
00115                     }
00116                     fprintf(f, "\n");
00117                 }
00118                 break;
00119             case RPM_CHAR_TYPE:
00120                 while (c--) {
00121                     char ch = (char) *((char *) dp);
00122                     fprintf(f, "       Data: %.3d 0x%2x %c (%d)\n", ct++,
00123                             (unsigned)(ch & 0xff),
00124                             (isprint(ch) ? ch : ' '),
00125                             (int) *((char *) dp));
00126                     dp += sizeof(char);
00127                 }
00128                 break;
00129             case RPM_STRING_TYPE:
00130             case RPM_STRING_ARRAY_TYPE:
00131             case RPM_I18NSTRING_TYPE:
00132                 while (c--) {
00133                     fprintf(f, "       Data: %.3d %s\n", ct++, (char *) dp);
00134                     dp = strchr(dp, 0);
00135                     dp++;
00136                 }
00137                 break;
00138             default:
00139                 fprintf(stderr, _("Data type %d not supported\n"), 
00140                         (int) p->info.type);
00141                 break;
00142             }
00143         }
00144         p++;
00145     }
00146 }
00147 

Generated on Fri Apr 4 14:39:39 2003 for rpm by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002