← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_compress.c

  • Committer: Brian Aker
  • Date: 2008-07-01 07:17:30 UTC
  • Revision ID: brian@tangent.org-20080701071730-y843dzfwz1nbca79
More mysys removal

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_compress.c
132
132
    *complen= len;
133
133
  DBUG_RETURN(0);
134
134
}
135
 
 
136
 
/*
137
 
  Internal representation of the frm blob is:
138
 
 
139
 
  ver     4 bytes
140
 
  orglen  4 bytes
141
 
  complen 4 bytes
142
 
*/
143
 
 
144
 
#define BLOB_HEADER 12
145
 
 
146
 
 
147
 
/*
148
 
  packfrm is a method used to compress the frm file for storage in a
149
 
  handler. This method was developed for the NDB handler and has been moved
150
 
  here to serve also other uses.
151
 
 
152
 
  SYNOPSIS
153
 
    packfrm()
154
 
    data                    Data reference to frm file data.
155
 
    len                     Length of frm file data
156
 
    out:pack_data           Reference to the pointer to the packed frm data
157
 
    out:pack_len            Length of packed frm file data
158
 
 
159
 
  NOTES
160
 
    data is replaced with compressed content
161
 
 
162
 
  RETURN VALUES
163
 
    0                       Success
164
 
    >0                      Failure
165
 
*/
166
 
 
167
 
int packfrm(uchar *data, size_t len,
168
 
            uchar **pack_data, size_t *pack_len)
169
 
{
170
 
  int error;
171
 
  size_t org_len, comp_len, blob_len;
172
 
  uchar *blob;
173
 
  DBUG_ENTER("packfrm");
174
 
  DBUG_PRINT("enter", ("data: 0x%lx  len: %lu", (long) data, (ulong) len));
175
 
 
176
 
  error= 1;
177
 
  org_len= len;
178
 
  if (my_compress((uchar*)data, &org_len, &comp_len))
179
 
    goto err;
180
 
 
181
 
  DBUG_PRINT("info", ("org_len: %lu  comp_len: %lu", (ulong) org_len,
182
 
                      (ulong) comp_len));
183
 
  DBUG_DUMP("compressed", data, org_len);
184
 
 
185
 
  error= 2;
186
 
  blob_len= BLOB_HEADER + org_len;
187
 
  if (!(blob= (uchar*) my_malloc(blob_len,MYF(MY_WME))))
188
 
    goto err;
189
 
 
190
 
  /* Store compressed blob in machine independent format */
191
 
  int4store(blob, 1);
192
 
  int4store(blob+4, (uint32) len);
193
 
  int4store(blob+8, (uint32) org_len);          /* compressed length */
194
 
 
195
 
  /* Copy frm data into blob, already in machine independent format */
196
 
  memcpy(blob+BLOB_HEADER, data, org_len);
197
 
 
198
 
  *pack_data= blob;
199
 
  *pack_len=  blob_len;
200
 
  error= 0;
201
 
 
202
 
  DBUG_PRINT("exit", ("pack_data: 0x%lx  pack_len: %lu",
203
 
                      (long) *pack_data, (ulong) *pack_len));
204
 
err:
205
 
  DBUG_RETURN(error);
206
 
 
207
 
}
208
 
 
209
 
/*
210
 
  unpackfrm is a method used to decompress the frm file received from a
211
 
  handler. This method was developed for the NDB handler and has been moved
212
 
  here to serve also other uses for other clustered storage engines.
213
 
 
214
 
  SYNOPSIS
215
 
    unpackfrm()
216
 
    pack_data               Data reference to packed frm file data
217
 
    out:unpack_data         Reference to the pointer to the unpacked frm data
218
 
    out:unpack_len          Length of unpacked frm file data
219
 
 
220
 
  RETURN VALUES¨
221
 
    0                       Success
222
 
    >0                      Failure
223
 
*/
224
 
 
225
 
int unpackfrm(uchar **unpack_data, size_t *unpack_len,
226
 
              const uchar *pack_data)
227
 
{
228
 
   uchar *data;
229
 
   size_t complen, orglen;
230
 
   ulong ver;
231
 
   DBUG_ENTER("unpackfrm");
232
 
   DBUG_PRINT("enter", ("pack_data: 0x%lx", (long) pack_data));
233
 
 
234
 
   ver=         uint4korr(pack_data);
235
 
   orglen=      uint4korr(pack_data+4);
236
 
   complen=     uint4korr(pack_data+8);
237
 
 
238
 
   DBUG_PRINT("blob",("ver: %lu  complen: %lu  orglen: %lu",
239
 
                      ver, (ulong) complen, (ulong) orglen));
240
 
   DBUG_DUMP("blob->data", pack_data + BLOB_HEADER, complen);
241
 
 
242
 
   if (ver != 1)
243
 
     DBUG_RETURN(1);
244
 
   if (!(data= my_malloc(max(orglen, complen), MYF(MY_WME))))
245
 
     DBUG_RETURN(2);
246
 
   memcpy(data, pack_data + BLOB_HEADER, complen);
247
 
 
248
 
   if (my_uncompress(data, complen, &orglen))
249
 
   {
250
 
     my_free(data, MYF(0));
251
 
     DBUG_RETURN(3);
252
 
   }
253
 
 
254
 
   *unpack_data= data;
255
 
   *unpack_len=  orglen;
256
 
 
257
 
   DBUG_PRINT("exit", ("frmdata: 0x%lx  len: %lu", (long) *unpack_data,
258
 
                       (ulong) *unpack_len));
259
 
   DBUG_RETURN(0);
260
 
}