satsolver  0.17.2
repopack.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2007, Novell Inc.
3  *
4  * This program is licensed under the BSD license, read LICENSE.BSD
5  * for further information
6  */
7 
8 /* pack/unpack functions for key data */
9 
10 #ifndef SATSOLVER_REPOPACK_H
11 #define SATSOLVER_REPOPACK_H
12 
13 static inline unsigned char *
14 data_read_id(unsigned char *dp, Id *idp)
15 {
16  Id x = 0;
17  unsigned char c;
18  for (;;)
19  {
20  c = *dp++;
21  if (!(c & 0x80))
22  {
23  *idp = (x << 7) ^ c;
24  return dp;
25  }
26  x = (x << 7) ^ c ^ 128;
27  }
28 }
29 
30 static inline unsigned char *
31 data_read_ideof(unsigned char *dp, Id *idp, int *eof)
32 {
33  Id x = 0;
34  unsigned char c;
35  for (;;)
36  {
37  c = *dp++;
38  if (!(c & 0x80))
39  {
40  if (c & 0x40)
41  {
42  c ^= 0x40;
43  *eof = 0;
44  }
45  else
46  *eof = 1;
47  *idp = (x << 6) ^ c;
48  return dp;
49  }
50  x = (x << 7) ^ c ^ 128;
51  }
52 }
53 
54 static inline unsigned char *
55 data_read_u32(unsigned char *dp, unsigned int *nump)
56 {
57  *nump = (dp[0] << 24) | (dp[1] << 16) | (dp[2] << 8) | dp[3];
58  return dp + 4;
59 }
60 
61 static inline unsigned char *
62 data_fetch(unsigned char *dp, KeyValue *kv, Repokey *key)
63 {
64  kv->eof = 1;
65  if (!dp)
66  return 0;
67  switch (key->type)
68  {
69  case REPOKEY_TYPE_VOID:
70  return dp;
71  case REPOKEY_TYPE_CONSTANT:
72  kv->num = key->size;
73  return dp;
74  case REPOKEY_TYPE_CONSTANTID:
75  kv->id = key->size;
76  return dp;
77  case REPOKEY_TYPE_STR:
78  kv->str = (const char *)dp;
79  return dp + strlen(kv->str) + 1;
80  case REPOKEY_TYPE_ID:
81  case REPOKEY_TYPE_DIR:
82  return data_read_id(dp, &kv->id);
83  case REPOKEY_TYPE_NUM:
84  return data_read_id(dp, &kv->num);
85  case REPOKEY_TYPE_U32:
86  return data_read_u32(dp, (unsigned int *)&kv->num);
87  case REPOKEY_TYPE_MD5:
88  kv->str = (const char *)dp;
89  return dp + SIZEOF_MD5;
90  case REPOKEY_TYPE_SHA1:
91  kv->str = (const char *)dp;
92  return dp + SIZEOF_SHA1;
93  case REPOKEY_TYPE_SHA256:
94  kv->str = (const char *)dp;
95  return dp + SIZEOF_SHA256;
96  case REPOKEY_TYPE_BINARY:
97  dp = data_read_id(dp, &kv->num);
98  kv->str = (const char *)dp;
99  return dp + kv->num;
100  case REPOKEY_TYPE_IDARRAY:
101  return data_read_ideof(dp, &kv->id, &kv->eof);
102  case REPOKEY_TYPE_DIRSTRARRAY:
103  dp = data_read_ideof(dp, &kv->id, &kv->eof);
104  kv->str = (const char *)dp;
105  return dp + strlen(kv->str) + 1;
106  case REPOKEY_TYPE_DIRNUMNUMARRAY:
107  dp = data_read_id(dp, &kv->id);
108  dp = data_read_id(dp, &kv->num);
109  return data_read_ideof(dp, &kv->num2, &kv->eof);
110  case REPOKEY_TYPE_FIXARRAY:
111  dp = data_read_id(dp, &kv->num);
112  return data_read_id(dp, &kv->id);
113  case REPOKEY_TYPE_FLEXARRAY:
114  return data_read_id(dp, &kv->num);
115  default:
116  return 0;
117  }
118 }
119 
120 static inline unsigned char *
121 data_skip(unsigned char *dp, int type)
122 {
123  unsigned char x;
124  switch (type)
125  {
126  case REPOKEY_TYPE_VOID:
127  case REPOKEY_TYPE_CONSTANT:
128  case REPOKEY_TYPE_CONSTANTID:
129  case REPOKEY_TYPE_DELETED:
130  return dp;
131  case REPOKEY_TYPE_ID:
132  case REPOKEY_TYPE_NUM:
133  case REPOKEY_TYPE_DIR:
134  while ((*dp & 0x80) != 0)
135  dp++;
136  return dp + 1;
137  case REPOKEY_TYPE_U32:
138  return dp + 4;
139  case REPOKEY_TYPE_MD5:
140  return dp + SIZEOF_MD5;
141  case REPOKEY_TYPE_SHA1:
142  return dp + SIZEOF_SHA1;
143  case REPOKEY_TYPE_SHA256:
144  return dp + SIZEOF_SHA256;
145  case REPOKEY_TYPE_IDARRAY:
146  case REPOKEY_TYPE_REL_IDARRAY:
147  while ((*dp & 0xc0) != 0)
148  dp++;
149  return dp + 1;
150  case REPOKEY_TYPE_STR:
151  while ((*dp) != 0)
152  dp++;
153  return dp + 1;
154  case REPOKEY_TYPE_BINARY:
155  {
156  Id len;
157  dp = data_read_id(dp, &len);
158  return dp + len;
159  }
160  case REPOKEY_TYPE_DIRSTRARRAY:
161  for (;;)
162  {
163  while ((*dp & 0x80) != 0)
164  dp++;
165  x = *dp++;
166  while ((*dp) != 0)
167  dp++;
168  dp++;
169  if (!(x & 0x40))
170  return dp;
171  }
172  case REPOKEY_TYPE_DIRNUMNUMARRAY:
173  for (;;)
174  {
175  while ((*dp & 0x80) != 0)
176  dp++;
177  dp++;
178  while ((*dp & 0x80) != 0)
179  dp++;
180  dp++;
181  while ((*dp & 0x80) != 0)
182  dp++;
183  if (!(*dp & 0x40))
184  return dp + 1;
185  dp++;
186  }
187  default:
188  return 0;
189  }
190 }
191 
192 static inline unsigned char *
193 data_skip_verify(unsigned char *dp, int type, int maxid, int maxdir)
194 {
195  Id id;
196  int eof;
197 
198  switch (type)
199  {
200  case REPOKEY_TYPE_VOID:
201  case REPOKEY_TYPE_CONSTANT:
202  case REPOKEY_TYPE_CONSTANTID:
203  case REPOKEY_TYPE_DELETED:
204  return dp;
205  case REPOKEY_TYPE_NUM:
206  while ((*dp & 0x80) != 0)
207  dp++;
208  return dp + 1;
209  case REPOKEY_TYPE_U32:
210  return dp + 4;
211  case REPOKEY_TYPE_MD5:
212  return dp + SIZEOF_MD5;
213  case REPOKEY_TYPE_SHA1:
214  return dp + SIZEOF_SHA1;
215  case REPOKEY_TYPE_SHA256:
216  return dp + SIZEOF_SHA256;
217  case REPOKEY_TYPE_ID:
218  dp = data_read_id(dp, &id);
219  if (id >= maxid)
220  return 0;
221  return dp;
222  case REPOKEY_TYPE_DIR:
223  dp = data_read_id(dp, &id);
224  if (id >= maxdir)
225  return 0;
226  return dp;
227  case REPOKEY_TYPE_IDARRAY:
228  for (;;)
229  {
230  dp = data_read_ideof(dp, &id, &eof);
231  if (id >= maxid)
232  return 0;
233  if (eof)
234  return dp;
235  }
236  case REPOKEY_TYPE_STR:
237  while ((*dp) != 0)
238  dp++;
239  return dp + 1;
240  case REPOKEY_TYPE_DIRSTRARRAY:
241  for (;;)
242  {
243  dp = data_read_ideof(dp, &id, &eof);
244  if (id >= maxdir)
245  return 0;
246  while ((*dp) != 0)
247  dp++;
248  dp++;
249  if (eof)
250  return dp;
251  }
252  case REPOKEY_TYPE_DIRNUMNUMARRAY:
253  for (;;)
254  {
255  dp = data_read_id(dp, &id);
256  if (id >= maxdir)
257  return 0;
258  while ((*dp & 0x80) != 0)
259  dp++;
260  dp++;
261  while ((*dp & 0x80) != 0)
262  dp++;
263  if (!(*dp & 0x40))
264  return dp + 1;
265  dp++;
266  }
267  default:
268  return 0;
269  }
270 }
271 
272 #endif /* SATSOLVER_REPOPACK */
Generated by   doxygen 1.8.4