← Back to branch summary

~mm-yuhu/gearmand/server-funcs

« back to all changes in this revision

Viewing changes to libgearman/byte_array.c

  • Committer: Brian Aker
  • Date: 2008-09-15 18:17:17 UTC
  • Revision ID: brian@gir.lan-20080915181717-mb6tl0n8kr8q76gx
Import from HG

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgearman/byte_array.c
 
1
#include "common.h"
 
2
 
 
3
gearman_return gearman_byte_array_check(gearman_byte_array_st *byte_array, size_t need)
 
4
{
 
5
  if (need && need > (size_t)(byte_array->current_size - (size_t)(byte_array->end - byte_array->byte_array)))
 
6
  {
 
7
    size_t current_offset= byte_array->end - byte_array->byte_array;
 
8
    char *new_value;
 
9
    size_t adjust;
 
10
    size_t new_size;
 
11
 
 
12
    /* This is the block multiplier. To keep it larger and surive division errors we must round it up */
 
13
    adjust= (need - (size_t)(byte_array->current_size - (size_t)(byte_array->end - byte_array->byte_array))) / byte_array->block_size;
 
14
    adjust++;
 
15
 
 
16
    new_size= sizeof(char) * (size_t)((adjust * byte_array->block_size) + byte_array->current_size);
 
17
    /* Test for overflow */
 
18
    if (new_size < need)
 
19
      return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
20
 
 
21
    new_value= (char *)realloc(byte_array->byte_array, new_size);
 
22
 
 
23
    if (new_value == NULL)
 
24
      return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
25
 
 
26
    byte_array->byte_array= new_value;
 
27
    byte_array->end= byte_array->byte_array + current_offset;
 
28
 
 
29
    byte_array->current_size+= (byte_array->block_size * adjust);
 
30
  }
 
31
 
 
32
  return GEARMAN_SUCCESS;
 
33
}
 
34
 
 
35
gearman_byte_array_st *gearman_byte_array_create(gearman_st *ptr, gearman_byte_array_st *byte_array, size_t initial_size)
 
36
{
 
37
  gearman_return rc;
 
38
 
 
39
  /* Saving malloc calls :) */
 
40
  if (byte_array)
 
41
  {
 
42
    memset(byte_array, 0, sizeof(gearman_byte_array_st));
 
43
    byte_array->is_allocated= GEARMAN_NOT_ALLOCATED;
 
44
  }
 
45
  else
 
46
  {
 
47
    byte_array= (gearman_byte_array_st *)malloc(sizeof(gearman_byte_array_st));
 
48
 
 
49
    if (byte_array == NULL)
 
50
      return NULL;
 
51
    memset(byte_array, 0, sizeof(gearman_byte_array_st));
 
52
    byte_array->is_allocated= GEARMAN_ALLOCATED;
 
53
  }
 
54
  byte_array->block_size= GEARMAN_BLOCK_SIZE;
 
55
  byte_array->root= ptr;
 
56
 
 
57
  rc=  gearman_byte_array_check(byte_array, initial_size);
 
58
  if (rc != GEARMAN_SUCCESS)
 
59
  {
 
60
    free(byte_array);
 
61
 
 
62
    return NULL;
 
63
  }
 
64
 
 
65
  WATCHPOINT_ASSERT(byte_array->byte_array == byte_array->end);
 
66
 
 
67
  return byte_array;
 
68
}
 
69
 
 
70
gearman_return gearman_byte_array_append_character(gearman_byte_array_st *byte_array, 
 
71
                                                   char character)
 
72
{
 
73
  gearman_return rc;
 
74
 
 
75
  WATCHPOINT_ASSERT(byte_array->is_allocated != GEARMAN_USED);
 
76
 
 
77
  rc=  gearman_byte_array_check(byte_array, 1);
 
78
 
 
79
  if (rc != GEARMAN_SUCCESS)
 
80
    return rc;
 
81
 
 
82
  *byte_array->end= ' ';
 
83
  byte_array->end++;
 
84
 
 
85
  return GEARMAN_SUCCESS;
 
86
}
 
87
 
 
88
gearman_return gearman_byte_array_append(gearman_byte_array_st *byte_array,
 
89
                                         const char *value, size_t length)
 
90
{
 
91
  gearman_return rc;
 
92
 
 
93
  if (length == 0)
 
94
    return GEARMAN_SUCCESS;
 
95
  WATCHPOINT_ASSERT(byte_array->is_allocated != GEARMAN_USED);
 
96
 
 
97
  rc= gearman_byte_array_check(byte_array, length);
 
98
 
 
99
  if (rc != GEARMAN_SUCCESS)
 
100
    return rc;
 
101
 
 
102
  WATCHPOINT_ASSERT(length <= byte_array->current_size);
 
103
  WATCHPOINT_ASSERT(byte_array->byte_array);
 
104
  WATCHPOINT_ASSERT(byte_array->end >= byte_array->byte_array);
 
105
 
 
106
  memcpy(byte_array->end, value, length);
 
107
  byte_array->end+= length;
 
108
 
 
109
  return GEARMAN_SUCCESS;
 
110
}
 
111
 
 
112
size_t gearman_byte_array_backspace(gearman_byte_array_st *byte_array, size_t remove)
 
113
{
 
114
  WATCHPOINT_ASSERT(byte_array->is_allocated != GEARMAN_USED);
 
115
 
 
116
  if (byte_array->end - byte_array->byte_array  > remove)
 
117
  {
 
118
    size_t difference;
 
119
 
 
120
    difference= byte_array->end - byte_array->byte_array;
 
121
    byte_array->end= byte_array->byte_array;
 
122
 
 
123
    return difference;
 
124
  }
 
125
  byte_array->end-= remove;
 
126
 
 
127
  return remove;
 
128
}
 
129
 
 
130
char *gearman_byte_array_c_copy(gearman_byte_array_st *byte_array)
 
131
{
 
132
  char *c_ptr;
 
133
 
 
134
  WATCHPOINT_ASSERT(byte_array->is_allocated != GEARMAN_USED);
 
135
 
 
136
  if (gearman_byte_array_length(byte_array) == 0)
 
137
    return NULL;
 
138
 
 
139
  c_ptr= (char *)malloc((gearman_byte_array_length(byte_array)+1) * sizeof(char));
 
140
 
 
141
  if (c_ptr == NULL)
 
142
    return NULL;
 
143
 
 
144
  memcpy(c_ptr, gearman_byte_array_value(byte_array), gearman_byte_array_length(byte_array));
 
145
  c_ptr[gearman_byte_array_length(byte_array)]= 0;
 
146
 
 
147
  return c_ptr;
 
148
}
 
149
 
 
150
gearman_return gearman_byte_array_reset(gearman_byte_array_st *byte_array)
 
151
{
 
152
  WATCHPOINT_ASSERT(byte_array->is_allocated != GEARMAN_USED);
 
153
  byte_array->end= byte_array->byte_array;
 
154
 
 
155
  return GEARMAN_SUCCESS;
 
156
}
 
157
 
 
158
void gearman_byte_array_free(gearman_byte_array_st *ptr)
 
159
{
 
160
  if (ptr == NULL)
 
161
    return;
 
162
 
 
163
  if (ptr->byte_array)
 
164
    free(ptr->byte_array);
 
165
 
 
166
  if (ptr->is_allocated == GEARMAN_ALLOCATED)
 
167
    free(ptr);
 
168
  else
 
169
    ptr->is_allocated= GEARMAN_USED;
 
170
}
 
171
 
 
172
 
 
173
gearman_return gearman_byte_array_store(gearman_byte_array_st *byte_array,
 
174
                                         const char *value, size_t length)
 
175
{
 
176
  gearman_return rc;
 
177
 
 
178
  (void)gearman_byte_array_reset(byte_array);
 
179
  rc= gearman_byte_array_append(byte_array, value, length);
 
180
 
 
181
  return rc;
 
182
}