← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/pack.cc

  • Committer: Mark Atwood
  • Date: 2011-11-20 08:50:16 UTC
  • mfrom: (2461.1.2 drizzle-build)
  • Revision ID: me@mark.atwood.name-20111120085016-2o4no5btx18x2gws
merge lp:~brianaker/drizzle/libdrizzle-refactor

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/pack.cc
145
145
 
146
146
uint8_t *drizzle_pack_string(char *string, uint8_t *ptr)
147
147
{
 
148
  if (string == NULL)
 
149
  {
 
150
    return NULL;
 
151
  }
 
152
 
148
153
  uint64_t size= strlen(string);
149
154
 
150
155
  ptr= drizzle_pack_length(size, ptr);
163
168
  drizzle_return_t ret= DRIZZLE_RETURN_OK;
164
169
  uint64_t length;
165
170
 
 
171
  if (con == NULL)
 
172
  {
 
173
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
174
  }
 
175
 
166
176
  length= drizzle_unpack_length(con, &ret);
167
177
  if (ret != DRIZZLE_RETURN_OK)
168
178
  {
178
188
  if (length < max_length)
179
189
  {
180
190
    if (length > 0)
 
191
    {
181
192
      memcpy(buffer, con->buffer_ptr, (size_t)length);
 
193
    }
182
194
 
183
195
    buffer[length]= 0;
184
196
  }
195
207
  return DRIZZLE_RETURN_OK;
196
208
}
197
209
 
198
 
uint8_t *drizzle_pack_auth(drizzle_con_st *con, uint8_t *ptr,
199
 
                           drizzle_return_t *ret_ptr)
 
210
uint8_t *drizzle_pack_auth(drizzle_con_st *con, uint8_t *ptr, drizzle_return_t *ret_ptr)
200
211
{
 
212
  if (con == NULL)
 
213
  {
 
214
    return NULL;
 
215
  }
 
216
 
 
217
  drizzle_return_t unused;
 
218
  if (ret_ptr == NULL)
 
219
  {
 
220
    ret_ptr= &unused;
 
221
  }
 
222
 
201
223
  if (con->user[0] != 0)
202
224
  {
203
225
    memcpy(ptr, con->user, strlen(con->user));
235
257
    {
236
258
      *ret_ptr= _pack_scramble_hash(con, ptr);
237
259
      if (*ret_ptr != DRIZZLE_RETURN_OK)
 
260
      {
238
261
        return ptr;
 
262
      }
239
263
    }
240
264
    else // We assume Drizzle
241
265
    {
246
270
    ptr+= DRIZZLE_MAX_SCRAMBLE_SIZE;
247
271
  }
248
272
 
249
 
  if (con->db[0] != 0)
 
273
  if (con->schema[0] != 0)
250
274
  {
251
 
    memcpy(ptr, con->db, strlen(con->db));
252
 
    ptr+= strlen(con->db);
 
275
    memcpy(ptr, con->schema, strlen(con->schema));
 
276
    ptr+= strlen(con->schema);
253
277
  }
254
278
 
255
279
  ptr[0]= 0;
256
280
  ptr++;
257
281
 
258
282
  *ret_ptr= DRIZZLE_RETURN_OK;
 
283
 
259
284
  return ptr;
260
285
}
261
286
 
266
291
static drizzle_return_t _pack_scramble_hash(drizzle_con_st *con,
267
292
                                            uint8_t *buffer)
268
293
{
269
 
  uint32_t x;
270
294
  SHA1_CTX ctx;
271
295
  uint8_t hash_tmp1[SHA1_DIGEST_LENGTH];
272
296
  uint8_t hash_tmp2[SHA1_DIGEST_LENGTH];
303
327
  SHA1Final(buffer, &ctx);
304
328
 
305
329
  /* Fourth, xor the last hash against the first password hash. */
306
 
  for (x= 0; x < SHA1_DIGEST_LENGTH; x++)
 
330
  for (uint32_t x= 0; x < SHA1_DIGEST_LENGTH; x++)
 
331
  {
307
332
    buffer[x]= buffer[x] ^ hash_tmp1[x];
 
333
  }
308
334
 
309
335
  return DRIZZLE_RETURN_OK;
310
336
}