← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_compress.c

  • Committer: Monty Taylor
  • Date: 2008-07-15 21:40:58 UTC
  • mfrom: (77.1.113 codestyle32)
  • mto: This revision was merged to the branch mainline in revision 176.
  • Revision ID: mordred@camelot-20080715214058-rm3phulldos9xehv
Merged from codestyle.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_compress.c
 
1
/* Copyright (C) 2000 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
/* Written by Sinisa Milivojevic <sinisa@mysql.com> */
 
17
 
 
18
#include <my_global.h>
 
19
#include <my_sys.h>
 
20
#include <m_string.h>
 
21
#include <zlib.h>
 
22
 
 
23
/*
 
24
   This replaces the packet with a compressed packet
 
25
 
 
26
   SYNOPSIS
 
27
     my_compress()
 
28
     packet     Data to compress. This is is replaced with the compressed data.
 
29
     len        Length of data to compress at 'packet'
 
30
     complen    out: 0 if packet was not compressed
 
31
 
 
32
   RETURN
 
33
     1   error. 'len' is not changed'
 
34
     0   ok.  In this case 'len' contains the size of the compressed packet
 
35
*/
 
36
 
 
37
bool my_compress(uchar *packet, size_t *len, size_t *complen)
 
38
{
 
39
  DBUG_ENTER("my_compress");
 
40
  if (*len < MIN_COMPRESS_LENGTH)
 
41
  {
 
42
    *complen=0;
 
43
    DBUG_PRINT("note",("Packet too short: Not compressed"));
 
44
  }
 
45
  else
 
46
  {
 
47
    uchar *compbuf=my_compress_alloc(packet,len,complen);
 
48
    if (!compbuf)
 
49
      DBUG_RETURN(*complen ? 0 : 1);
 
50
    memcpy(packet,compbuf,*len);
 
51
    my_free(compbuf,MYF(MY_WME));
 
52
  }
 
53
  DBUG_RETURN(0);
 
54
}
 
55
 
 
56
 
 
57
uchar *my_compress_alloc(const uchar *packet, size_t *len, size_t *complen)
 
58
{
 
59
  uchar *compbuf;
 
60
  uLongf tmp_complen;
 
61
  int res;
 
62
  *complen=  *len * 120 / 100 + 12;
 
63
 
 
64
  if (!(compbuf= (uchar *) my_malloc(*complen, MYF(MY_WME))))
 
65
    return 0;                                   /* Not enough memory */
 
66
 
 
67
  tmp_complen= *complen;
 
68
  res= compress((Bytef*) compbuf, &tmp_complen, (Bytef*) packet, (uLong) *len);
 
69
  *complen=    tmp_complen;
 
70
 
 
71
  if (res != Z_OK)
 
72
  {
 
73
    my_free(compbuf, MYF(MY_WME));
 
74
    return 0;
 
75
  }
 
76
 
 
77
  if (*complen >= *len)
 
78
  {
 
79
    *complen= 0;
 
80
    my_free(compbuf, MYF(MY_WME));
 
81
    DBUG_PRINT("note",("Packet got longer on compression; Not compressed"));
 
82
    return 0;
 
83
  }
 
84
  /* Store length of compressed packet in *len */
 
85
  swap_variables(size_t, *len, *complen);
 
86
  return compbuf;
 
87
}
 
88
 
 
89
 
 
90
/*
 
91
  Uncompress packet
 
92
 
 
93
   SYNOPSIS
 
94
     my_uncompress()
 
95
     packet     Compressed data. This is is replaced with the orignal data.
 
96
     len        Length of compressed data
 
97
     complen    Length of the packet buffer (must be enough for the original
 
98
                data)
 
99
 
 
100
   RETURN
 
101
     1   error
 
102
     0   ok.  In this case 'complen' contains the updated size of the
 
103
              real data.
 
104
*/
 
105
 
 
106
bool my_uncompress(uchar *packet, size_t len, size_t *complen)
 
107
{
 
108
  uLongf tmp_complen;
 
109
  DBUG_ENTER("my_uncompress");
 
110
 
 
111
  if (*complen)                                 /* If compressed */
 
112
  {
 
113
    uchar *compbuf= (uchar *) my_malloc(*complen,MYF(MY_WME));
 
114
    int error;
 
115
    if (!compbuf)
 
116
      DBUG_RETURN(1);                           /* Not enough memory */
 
117
 
 
118
    tmp_complen= *complen;
 
119
    error= uncompress((Bytef*) compbuf, &tmp_complen, (Bytef*) packet,
 
120
                      (uLong) len);
 
121
    *complen= tmp_complen;
 
122
    if (error != Z_OK)
 
123
    {                                           /* Probably wrong packet */
 
124
      DBUG_PRINT("error",("Can't uncompress packet, error: %d",error));
 
125
      my_free(compbuf, MYF(MY_WME));
 
126
      DBUG_RETURN(1);
 
127
    }
 
128
    memcpy(packet, compbuf, *complen);
 
129
    my_free(compbuf, MYF(MY_WME));
 
130
  }
 
131
  else
 
132
    *complen= len;
 
133
  DBUG_RETURN(0);
 
134
}