← 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-14 07:30:41 UTC
  • Revision ID: me@mark.atwood.name-20111114073041-mo2hgg8ouseo2kpu
release 2011.11.29

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