← Back to branch summary

~ubuntu-branches/debian/squeeze/erlang/squeeze

« back to all changes in this revision

Viewing changes to erts/emulator/drivers/common/zlib_drv.c

  • Committer: Bazaar Package Importer
  • Author(s): Erlang Packagers, Sergei Golovan
  • Date: 2006-12-03 17:07:44 UTC
  • mfrom: (2.1.11 feisty)
  • Revision ID: james.westby@ubuntu.com-20061203170744-rghjwupacqlzs6kv
Tags: 1:11.b.2-4
[ Sergei Golovan ]
Fixed erlang-base and erlang-base-hipe prerm scripts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
erts/emulator/drivers/common/zlib_drv.c
52
52
#define GET_BUFSZ       19
53
53
#define GET_QSIZE       20
54
54
 
 
55
#define ADLER32_1         21
 
56
#define ADLER32_2         22
 
57
 
55
58
#define DEFAULT_BUFSZ   4000
56
59
 
57
60
static int zlib_init(void);
94
97
    int binsz;
95
98
    int binsz_need;
96
99
    uLong crc;
97
 
    int   want_crc;     /* 1 if crc is calculated on clear text */
 
100
    int inflate_eos_seen;
 
101
    int want_crc;       /* 1 if crc is calculated on clear text */
98
102
    ErlDrvPort port;    /* the associcated port */
99
103
} ZLibData;
100
104
 
128
132
        return erl_errno_id(errno);
129
133
    case Z_STREAM_ERROR:
130
134
        *err = 1;
131
 
        return "stream";
 
135
        return "stream_error";
132
136
    case Z_DATA_ERROR:
133
137
        *err = 1;
134
 
        return "data";
 
138
        return "data_error";
135
139
    case Z_MEM_ERROR:
136
140
        *err = 1;
137
 
        return "mem";
 
141
        return "mem_error";
138
142
    case Z_BUF_ERROR:
139
143
        *err = 1;
140
 
        return "buf";
 
144
        return "buf_error";
141
145
    case Z_VERSION_ERROR:
142
146
        *err = 1;
143
 
        return "version";
 
147
        return "version_error";
144
148
    default:
145
149
        *err = 1;
146
 
        return "unknown";
 
150
        return "unknown_error";
147
151
    }
148
152
}
149
153
 
168
172
    return len;
169
173
}
170
174
 
171
 
static int zlib_value(int value, char** rbuf, int rlen)
 
175
static int zlib_value2(int msg_code, int value, char** rbuf, int rlen)
172
176
{
173
 
    int msg_code = 2; /* 2 = integer */
174
177
    char* dst = *rbuf;
175
178
 
176
 
    if (rlen  < 5)
 
179
    if (rlen  < 5) {
177
180
        return -1;
 
181
    }
178
182
    *dst++ = msg_code;
179
183
    *dst++ = (value >> 24) & 0xff;
180
184
    *dst++ = (value >> 16) & 0xff;
181
185
    *dst++ = (value >> 8) & 0xff;
182
 
    *dst++ = (value >> 0) & 0xff;
 
186
    *dst++ = value & 0xff;
183
187
    return 5;
184
188
}
185
189
 
 
190
static int zlib_value(int value, char** rbuf, int rlen)
 
191
{
 
192
    return zlib_value2(2, value, rbuf, rlen);
 
193
}
 
194
 
186
195
static int zlib_output_init(ZLibData* d)
187
196
{
188
197
    if (d->bin != NULL)
190
199
    if ((d->bin = driver_alloc_binary(d->binsz_need)) == NULL)
191
200
        return -1;
192
201
    d->binsz = d->binsz_need;
193
 
    d->s.next_out = d->bin->orig_bytes;
 
202
    d->s.next_out = (unsigned char*)d->bin->orig_bytes;
194
203
    d->s.avail_out = d->binsz;
195
204
    return 0;
196
205
}
227
236
        int vlen;
228
237
        SysIOVec* iov = driver_peekq(d->port, &vlen);
229
238
        int len;
 
239
        int possibly_more_output = 0;
230
240
 
231
241
        d->s.next_in = iov[0].iov_base;
232
242
        d->s.avail_in = iov[0].iov_len;
233
 
 
234
 
        while((d->s.avail_in > 0) && (res != Z_STREAM_END)) {
 
243
        while((possibly_more_output || (d->s.avail_in > 0)) && (res != Z_STREAM_END)) {
235
244
            res = inflate(&d->s, Z_NO_FLUSH);
236
 
            if (res < 0)
237
 
                return res;
238
 
            if (d->s.avail_out == 0) {
 
245
            if (res == Z_NEED_DICT) {
 
246
                /* Essential to eat the header bytes that zlib has looked at */
 
247
                len = iov[0].iov_len - d->s.avail_in;
 
248
                driver_deq(d->port, len);
 
249
                return res;
 
250
            }
 
251
            if (res < 0) {
 
252
                return res;
 
253
            }
 
254
            if (d->s.avail_out != 0) {
 
255
                possibly_more_output = 0;
 
256
            } else {
239
257
                if (d->want_crc)
240
 
                    d->crc = crc32(d->crc, d->bin->orig_bytes,
 
258
                    d->crc = crc32(d->crc, (unsigned char*)d->bin->orig_bytes,
241
259
                                   d->binsz - d->s.avail_out);
242
260
                zlib_output(d);
 
261
                possibly_more_output = 1;
243
262
            }
244
263
        }
245
264
        len = iov[0].iov_len - d->s.avail_in;
246
265
        driver_deq(d->port, len);
247
266
    }
248
267
 
249
 
    if (flush != Z_NO_FLUSH) {
250
 
        if ((res = inflate(&d->s, flush)) < 0)
251
 
            return res;
252
 
        while(d->s.avail_out < d->binsz) {
253
 
            if (d->want_crc)
254
 
                d->crc = crc32(d->crc, d->bin->orig_bytes,
255
 
                               d->binsz - d->s.avail_out);
256
 
            zlib_output(d);
257
 
            if (res == Z_STREAM_END)
258
 
                break;
259
 
            if ((res = inflate(&d->s, flush)) < 0)
260
 
                return res;
261
 
        }
 
268
    if (d->want_crc) {
 
269
       d->crc = crc32(d->crc, d->bin->orig_bytes,
 
270
                      d->binsz - d->s.avail_out);
 
271
    }
 
272
    zlib_output(d);
 
273
    if (res == Z_STREAM_END) {       
 
274
       d->inflate_eos_seen = 1;
262
275
    }
263
276
    return res;
264
277
}
281
294
        d->s.avail_in = iov[0].iov_len;
282
295
 
283
296
        while((d->s.avail_in > 0) && (res != Z_STREAM_END)) {
284
 
            if ((res = deflate(&d->s, Z_NO_FLUSH)) < 0)
 
297
            if ((res = deflate(&d->s, Z_NO_FLUSH)) < 0) {
285
298
                return res;
286
 
            if (d->s.avail_out == 0)
 
299
            }
 
300
            if (d->s.avail_out == 0) {
287
301
                zlib_output(d);
 
302
            }
288
303
        }
289
304
        len = iov[0].iov_len - d->s.avail_in;
290
 
        if (d->want_crc)
 
305
        if (d->want_crc) {
291
306
            d->crc = crc32(d->crc, iov[0].iov_base, len);
 
307
        }
292
308
        driver_deq(d->port, len);
293
309
    }
294
310
 
295
311
    if (flush != Z_NO_FLUSH) {
296
 
        if ((res = deflate(&d->s, flush)) < 0)
 
312
        if ((res = deflate(&d->s, flush)) < 0) {
297
313
            return res;
298
 
        while(d->s.avail_out < d->binsz) {
299
 
            zlib_output(d);
300
 
            if (res == Z_STREAM_END)
301
 
                break;
302
 
            if ((res = deflate(&d->s, flush)) < 0)
303
 
                return res;
 
314
        }
 
315
        if (flush == Z_FINISH) {
 
316
            while (d->s.avail_out < d->binsz) {
 
317
                zlib_output(d);
 
318
                if (res == Z_STREAM_END) {
 
319
                    break;
 
320
                }
 
321
                if ((res = deflate(&d->s, flush)) < 0) {
 
322
                    return res;
 
323
                }
 
324
            }
 
325
        } else {
 
326
            while (d->s.avail_out < d->binsz) {
 
327
                zlib_output(d);
 
328
                if (res == Z_STREAM_END) {
 
329
                    break;
 
330
                }
 
331
            }
304
332
        }
305
333
    }
306
334
    return res;
343
371
    d->binsz     = 0;
344
372
    d->binsz_need = DEFAULT_BUFSZ;
345
373
    d->crc       = crc32(0L, Z_NULL, 0);
 
374
    d->inflate_eos_seen = 0;
346
375
    d->want_crc  = 0;
347
376
    return (ErlDrvData)d;
348
377
}
400
429
        
401
430
    case DEFLATE_SETDICT:
402
431
        if (d->state != ST_DEFLATE) goto badarg;
403
 
        res = deflateSetDictionary(&d->s, buf, len);
404
 
        return zlib_return(res, rbuf, rlen);
 
432
        res = deflateSetDictionary(&d->s, (unsigned char*)buf, len);
 
433
        if (res == Z_OK) {
 
434
            return zlib_value(d->s.adler, rbuf, rlen);
 
435
        } else {
 
436
            return zlib_return(res, rbuf, rlen);
 
437
        }
405
438
 
406
439
    case DEFLATE_RESET:
407
440
        if (len != 0) goto badarg;
436
469
        res = inflateInit(&d->s);
437
470
        if (res == Z_OK) {
438
471
            d->state = ST_INFLATE;
 
472
            d->inflate_eos_seen = 0;
439
473
            d->want_crc = 0;
440
474
            d->crc = crc32(0L, Z_NULL, 0);
441
475
        }
450
484
        res = inflateInit2(&d->s, wbits);
451
485
        if (res == Z_OK) {
452
486
            d->state = ST_INFLATE;
 
487
            d->inflate_eos_seen = 0;
453
488
            d->want_crc = (wbits < 0);
454
489
            d->crc = crc32(0L, Z_NULL, 0);
455
490
        }
458
493
        
459
494
    case INFLATE_SETDICT:
460
495
        if (d->state != ST_INFLATE) goto badarg;
461
 
        res = inflateSetDictionary(&d->s, buf, len);
 
496
        res = inflateSetDictionary(&d->s, (unsigned char*)buf, len);
462
497
        return zlib_return(res, rbuf, rlen);
463
498
 
464
499
    case INFLATE_SYNC:
465
500
        if (d->state != ST_INFLATE) goto badarg;
466
501
        if (len != 0) goto badarg;
467
 
        res = inflateSync(&d->s);
 
502
        if (driver_sizeq(d->port) == 0) {
 
503
            res = Z_BUF_ERROR;
 
504
        } else {
 
505
            int vlen;
 
506
            SysIOVec* iov = driver_peekq(d->port, &vlen);
 
507
 
 
508
            d->s.next_in = iov[0].iov_base;
 
509
            d->s.avail_in = iov[0].iov_len;
 
510
            res = inflateSync(&d->s);
 
511
        }
468
512
        return zlib_return(res, rbuf, rlen);
469
513
 
470
514
    case INFLATE_RESET:
472
516
        if (len != 0) goto badarg;
473
517
        driver_deq(d->port, driver_sizeq(d->port));
474
518
        res = inflateReset(&d->s);
 
519
        d->inflate_eos_seen = 0;
475
520
        return zlib_return(res, rbuf, rlen);
476
521
 
477
522
    case INFLATE_END:
479
524
        if (len != 0) goto badarg;
480
525
        driver_deq(d->port, driver_sizeq(d->port));
481
526
        res = inflateEnd(&d->s);
 
527
        if (res == Z_OK && d->inflate_eos_seen == 0) {
 
528
            res = Z_DATA_ERROR;
 
529
        }
482
530
        d->state = ST_NONE;
483
531
        return zlib_return(res, rbuf, rlen);
484
532
 
486
534
        if (d->state != ST_INFLATE) goto badarg;
487
535
        if (len != 4) goto badarg;
488
536
        res = zlib_inflate(d, i32(buf));
489
 
        return zlib_return(res, rbuf, rlen);
 
537
        if (res == Z_NEED_DICT) {
 
538
            return zlib_value2(3, d->s.adler, rbuf, rlen);
 
539
        } else {
 
540
            return zlib_return(res, rbuf, rlen);
 
541
        }
490
542
 
491
543
    case GET_QSIZE:
492
544
        return zlib_value(driver_sizeq(d->port), rbuf, rlen);
520
572
 
521
573
    case CRC32_1: {
522
574
        uLong crc = crc32(0L, Z_NULL, 0);
523
 
        crc = crc32(crc, buf, len);
 
575
        crc = crc32(crc, (unsigned char*)buf, len);
524
576
        return zlib_value(crc, rbuf, rlen);
525
577
    }
526
578
        
528
580
        uLong crc;
529
581
        if (len < 4) goto badarg;
530
582
        crc = i32(buf);
531
 
        crc = crc32(crc, buf+4, len-4);
 
583
        crc = crc32(crc, (unsigned char*)buf+4, len-4);
532
584
        return zlib_value(crc, rbuf, rlen);
533
585
    }
 
586
 
 
587
    case ADLER32_1: {
 
588
        uLong adler = adler32(0L, Z_NULL, 0);
 
589
        adler = adler32(adler, buf, len);
 
590
        return zlib_value(adler, rbuf, rlen);
 
591
    }
 
592
        
 
593
    case ADLER32_2: {
 
594
        uLong adler;
 
595
        if (len < 4) goto badarg;
 
596
        adler = i32(buf);
 
597
        adler = adler32(adler, buf+4, len-4);
 
598
        return zlib_value(adler, rbuf, rlen);
 
599
    }
534
600
    }
535
601
 
536
602
 badarg: