← Back to branch summary

~ubuntu-branches/ubuntu/precise/rpm/precise-proposed

« back to all changes in this revision

Viewing changes to lib/header_internal.c

  • Committer: Bazaar Package Importer
  • Author(s): Michal Čihař
  • Date: 2010-06-28 11:12:30 UTC
  • mfrom: (17.2.5 sid)
  • Revision ID: james.westby@ubuntu.com-20100628111230-8ggjjhgpvrnr3ybx
Tags: 4.8.1-5
http://bugs.debian.org/587366
Fix compilation on hurd and kfreebsd (Closes: #587366).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/header_internal.c
17
17
    return n;
18
18
}
19
19
 
20
 
char ** headerGetLangs(Header h)
21
 
{
22
 
    char **s, *e, **table;
23
 
    rpmTagType type;
24
 
    rpm_count_t i, count;
25
 
 
26
 
    if (!headerGetRawEntry(h, HEADER_I18NTABLE, &type, (rpm_data_t)&s, &count))
27
 
        return NULL;
28
 
 
29
 
    /* XXX xcalloc never returns NULL. */
30
 
    if ((table = (char **)xcalloc((count+1), sizeof(char *))) == NULL)
31
 
        return NULL;
32
 
 
33
 
    for (i = 0, e = *s; i < count; i++, e += strlen(e)+1)
34
 
        table[i] = e;
35
 
    table[count] = NULL;
36
 
 
37
 
    return table;       /* LCL: double indirection? */
38
 
}
39
 
 
40
 
void headerDump(Header h, FILE *f, int flags)
41
 
{
42
 
    int i;
43
 
    indexEntry p;
44
 
    const char * tag;
45
 
    const char * type;
46
 
 
47
 
    /* First write out the length of the index (count of index entries) */
48
 
    fprintf(f, "Entry count: %d\n", h->indexUsed);
49
 
 
50
 
    /* Now write the index */
51
 
    p = h->index;
52
 
    fprintf(f, "\n             CT  TAG                  TYPE         "
53
 
                "      OFSET      COUNT\n");
54
 
    for (i = 0; i < h->indexUsed; i++) {
55
 
        switch (p->info.type) {
56
 
        case RPM_NULL_TYPE:
57
 
            type = "NULL";
58
 
            break;
59
 
        case RPM_CHAR_TYPE:
60
 
            type = "CHAR";
61
 
            break;
62
 
        case RPM_BIN_TYPE:
63
 
            type = "BIN";
64
 
            break;
65
 
        case RPM_INT8_TYPE:
66
 
            type = "INT8";
67
 
            break;
68
 
        case RPM_INT16_TYPE:
69
 
            type = "INT16";
70
 
            break;
71
 
        case RPM_INT32_TYPE:
72
 
            type = "INT32";
73
 
            break;
74
 
        case RPM_INT64_TYPE:
75
 
            type = "INT64";
76
 
            break;
77
 
        case RPM_STRING_TYPE:
78
 
            type = "STRING";
79
 
            break;
80
 
        case RPM_STRING_ARRAY_TYPE:
81
 
            type = "STRING_ARRAY";
82
 
            break;
83
 
        case RPM_I18NSTRING_TYPE:
84
 
            type = "I18N_STRING";
85
 
            break;
86
 
        default:
87
 
            type = "(unknown)";
88
 
            break;
89
 
        }
90
 
 
91
 
        tag = rpmTagGetName(p->info.tag);
92
 
 
93
 
        fprintf(f, "Entry      : %3.3d (%d)%-14s %-18s 0x%.8x %.8d\n", i,
94
 
                p->info.tag, tag, type, (unsigned) p->info.offset,
95
 
                (int) p->info.count);
96
 
 
97
 
        if (flags & HEADER_DUMP_INLINE) {
98
 
            char *dp = p->data;
99
 
            int c = p->info.count;
100
 
            int ct = 0;
101
 
 
102
 
            /* Print the data inline */
103
 
            switch (p->info.type) {
104
 
            case RPM_INT32_TYPE:
105
 
                while (c--) {
106
 
                    fprintf(f, "       Data: %.3d 0x%08x (%d)\n", ct++,
107
 
                            (unsigned) *((int32_t *) dp),
108
 
                            (int) *((int32_t *) dp));
109
 
                    dp += sizeof(int32_t);
110
 
                }
111
 
                break;
112
 
 
113
 
            case RPM_INT16_TYPE:
114
 
                while (c--) {
115
 
                    fprintf(f, "       Data: %.3d 0x%04x (%d)\n", ct++,
116
 
                            (unsigned) (*((int16_t *) dp) & 0xffff),
117
 
                            (int) *((int16_t *) dp));
118
 
                    dp += sizeof(int16_t);
119
 
                }
120
 
                break;
121
 
            case RPM_INT8_TYPE:
122
 
                while (c--) {
123
 
                    fprintf(f, "       Data: %.3d 0x%02x (%d)\n", ct++,
124
 
                            (unsigned) (*((int8_t *) dp) & 0xff),
125
 
                            (int) *((int8_t *) dp));
126
 
                    dp += sizeof(int8_t);
127
 
                }
128
 
                break;
129
 
            case RPM_BIN_TYPE:
130
 
                while (c > 0) {
131
 
                    fprintf(f, "       Data: %.3d ", ct);
132
 
                    while (c--) {
133
 
                        fprintf(f, "%02x ", (unsigned) (*(int8_t *)dp & 0xff));
134
 
                        ct++;
135
 
                        dp += sizeof(int8_t);
136
 
                        if (! (ct % 8)) {
137
 
                            break;
138
 
                        }
139
 
                    }
140
 
                    fprintf(f, "\n");
141
 
                }
142
 
                break;
143
 
            case RPM_CHAR_TYPE:
144
 
                while (c--) {
145
 
                    char ch = (char) *((char *) dp);
146
 
                    fprintf(f, "       Data: %.3d 0x%2x %c (%d)\n", ct++,
147
 
                            (unsigned)(ch & 0xff),
148
 
                            (isprint(ch) ? ch : ' '),
149
 
                            (int) *((char *) dp));
150
 
                    dp += sizeof(char);
151
 
                }
152
 
                break;
153
 
            case RPM_STRING_TYPE:
154
 
            case RPM_STRING_ARRAY_TYPE:
155
 
            case RPM_I18NSTRING_TYPE:
156
 
                while (c--) {
157
 
                    fprintf(f, "       Data: %.3d %s\n", ct++, (char *) dp);
158
 
                    dp = strchr(dp, 0);
159
 
                    dp++;
160
 
                }
161
 
                break;
162
 
            default:
163
 
                fprintf(stderr, _("Data type %d not supported\n"), 
164
 
                        (int) p->info.type);
165
 
                break;
166
 
            }
167
 
        }
168
 
        p++;
169
 
    }
170
 
}
171
 
 
172
20
/*
173
21
 * Backwards compatibility wrappers for legacy interfaces.
174
22
 * Remove these some day...