Changeset 5454

Show
Ignore:
Timestamp:
03/26/08 06:22:09 (4 months ago)
Author:
morris
Message:

Rewrite zlib support to fix some bugs

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • libwired/trunk/libwired/p7/wi-p7-socket.c

    r5437 r5454  
    148148         
    149149        wi_boolean_t                                                    compression_enabled; 
    150         z_stream                                                                compression_stream; 
    151         z_stream                                                                decompression_stream; 
    152150         
    153151        wi_boolean_t                                                    checksum_enabled; 
    …… 
    195193static wi_p7_message_t *                                        _wi_p7_socket_read_xml_message(wi_p7_socket_t *, wi_time_interval_t, wi_string_t *); 
    196194 
    197 static wi_boolean_t                                                     _wi_p7_socket_configure_compression_streams(wi_p7_socket_t *); 
    198 static wi_integer_t                                                     _wi_p7_socket_xcompress_buffer(wi_p7_socket_t *, _wi_p7_socket_compression_t, const void *, uint32_t); 
    199 static int                                                                      _wi_p7_socket_xflate_buffer(z_stream *, _wi_p7_socket_compression_t, const void *, uint32_t, uint32_t *, void *, uint32_t *); 
     195static wi_integer_t                                                     _wi_p7_socket_deflate(wi_p7_socket_t *, const void *, uint32_t); 
     196static wi_integer_t                                                     _wi_p7_socket_inflate(wi_p7_socket_t *, const void *, uint32_t); 
    200197 
    201198static void                                                                     _wi_p7_socket_configure_checksum(wi_p7_socket_t *); 
    …… 
    536533        if(!wi_is_equal(p7_message->name, WI_STR("p7.handshake.client_handshake"))) { 
    537534                wi_error_set_libwired_p7_error(WI_ERROR_P7_HANDSHAKEFAILED, 
    538                         WI_STR("Message should be \"p7.client_handshake\", not \"%@\""), 
     535                        WI_STR("Message should be \"p7.handshake.client_handshake\", not \"%@\""), 
    539536                        p7_message->name); 
    540537                 
    …… 
    739736        data = wi_rsa_encrypt(p7_socket->public_key, wi_cipher_key(p7_socket->cipher)); 
    740737         
     738        if(!data) 
     739                return false; 
     740         
    741741        if(!wi_p7_message_set_data_for_name(p7_message, data, WI_STR("p7.encryption.cipher.key"))) 
    742742                return false; 
    …… 
    746746        if(data) { 
    747747                data = wi_rsa_encrypt(p7_socket->public_key, data); 
     748                 
     749                if(!data) 
     750                        return false; 
    748751                 
    749752                if(!wi_p7_message_set_data_for_name(p7_message, data, WI_STR("p7.encryption.cipher.iv"))) 
    …… 
    877880        key = wi_rsa_decrypt(p7_socket->private_key, key); 
    878881         
    879         if(iv) 
     882        if(!key) 
     883                return false; 
     884         
     885        if(iv) { 
    880886                iv = wi_rsa_decrypt(p7_socket->private_key, iv); 
     887                 
     888                if(!iv) 
     889                        return false; 
     890        } 
    881891         
    882892        p7_socket->cipher = wi_cipher_init_with_key(wi_cipher_alloc(), _WI_P7_ENCRYPTION_OPTIONS_TO_CIPHER(p7_socket->options), key, iv); 
    …… 
    10911101         
    10921102        if(p7_socket->compression_enabled) { 
    1093                 compressed_size = _wi_p7_socket_xcompress_buffer(p7_socket, 
    1094                                                                                                                  _WI_P7_SOCKET_COMPRESS, 
    1095                                                                                                                  send_buffer, 
    1096                                                                                                                  send_size); 
     1103                compressed_size = _wi_p7_socket_deflate(p7_socket, send_buffer, send_size); 
    10971104                 
    10981105                if(compressed_size < 0) 
    …… 
    11391146        if(p7_socket->checksum_enabled) { 
    11401147                _wi_p7_socket_checksum_binary_message(p7_socket, p7_message, checksum_buffer); 
    1141  
     1148                 
    11421149                if(wi_socket_write_buffer(p7_socket->socket, timeout, checksum_buffer, p7_socket->checksum_length) < 0) 
    11431150                        return false; 
    …… 
    12181225         
    12191226        if(p7_socket->compression_enabled) { 
    1220                 decompressed_size = _wi_p7_socket_xcompress_buffer(p7_socket, 
    1221                                                                                                                    _WI_P7_SOCKET_DECOMPRESS, 
    1222                                                                                                                    p7_message->binary_buffer, 
    1223                                                                                                                    p7_message->binary_size); 
     1227                decompressed_size = _wi_p7_socket_inflate(p7_socket, p7_message->binary_buffer, p7_message->binary_size); 
    12241228                 
    12251229                if(decompressed_size < 0) 
    …… 
    13031307#pragma mark - 
    13041308 
    1305 static wi_boolean_t _wi_p7_socket_configure_compression_streams(wi_p7_socket_t *p7_socket) { 
    1306         int                     err; 
    1307  
    1308         err = deflateInit(&p7_socket->compression_stream, Z_DEFAULT_COMPRESSION); 
     1309static wi_integer_t _wi_p7_socket_deflate(wi_p7_socket_t *p7_socket, const void *in_buffer, uint32_t in_size) { 
     1310        z_stream                stream; 
     1311        int                             err, enderr; 
     1312         
     1313        p7_socket->compression_buffer_length = (in_size * 2) + 16; 
     1314 
     1315        if(!p7_socket->compression_buffer) 
     1316                p7_socket->compression_buffer = wi_malloc(p7_socket->compression_buffer_length); 
     1317        else 
     1318                p7_socket->compression_buffer = wi_realloc(p7_socket->compression_buffer, p7_socket->compression_buffer_length); 
     1319 
     1320        stream.data_type        = Z_UNKNOWN; 
     1321        stream.zalloc           = Z_NULL; 
     1322        stream.zfree            = Z_NULL; 
     1323        stream.opaque           = Z_NULL; 
     1324        stream.next_in          = (unsigned char *) in_buffer; 
     1325        stream.avail_in         = in_size; 
     1326        stream.next_out         = p7_socket->compression_buffer; 
     1327        stream.avail_out        = p7_socket->compression_buffer_length; 
     1328         
     1329        err = deflateInit(&stream, Z_DEFAULT_COMPRESSION); 
    13091330         
    13101331        if(err != Z_OK) { 
    13111332                wi_error_set_zlib_error(err); 
    13121333                 
    1313                 return false; 
    1314         } 
    1315          
    1316         err = inflateInit(&p7_socket->decompression_stream); 
    1317          
    1318         if(err != Z_OK) { 
     1334                return -1; 
     1335        } 
     1336         
     1337        err = deflate(&stream, Z_FINISH); 
     1338        enderr = deflateEnd(&stream); 
     1339         
     1340        if(err != Z_STREAM_END) { 
     1341                if(err == Z_OK) 
     1342                        wi_error_set_zlib_error(Z_BUF_ERROR); 
     1343                else 
     1344                        wi_error_set_zlib_error(err); 
     1345                 
     1346                return -1; 
     1347        } 
     1348         
     1349        if(enderr != Z_OK) { 
    13191350                wi_error_set_zlib_error(err); 
    13201351                 
    1321                 return false; 
    1322         } 
    1323          
    1324         p7_socket->compression_enabled = true; 
    1325          
    1326         return true; 
    1327 } 
    1328  
    1329  
    1330  
    1331 static wi_integer_t _wi_p7_socket_xcompress_buffer(wi_p7_socket_t *p7_socket, _wi_p7_socket_compression_t compression, const void *in_buffer, uint32_t in_size) { 
    1332         const void                      *input; 
    1333         void                            *output; 
    1334         z_stream                        *stream; 
    1335         uint32_t                        offset, input_size, input_processed, output_size, total_size; 
    1336         int                                     err; 
    1337          
    1338         if(!p7_socket->compression_buffer) { 
    1339                 p7_socket->compression_buffer_length = in_size * 4; 
    1340                 p7_socket->compression_buffer = wi_malloc(p7_socket->compression_buffer_length); 
    1341         } 
    1342         else if(in_size > p7_socket->compression_buffer_length) { 
    1343                 p7_socket->compression_buffer_length = in_size * 4; 
    1344                 p7_socket->compression_buffer = wi_realloc(p7_socket->compression_buffer, p7_socket->compression_buffer_length); 
    1345         } 
    1346          
    1347         stream                  = (compression == _WI_P7_SOCKET_COMPRESS) ? &p7_socket->compression_stream : &p7_socket->decompression_stream; 
    1348         input                   = in_buffer; 
    1349         input_size              = in_size; 
    1350         output                  = p7_socket->compression_buffer; 
    1351         output_size             = p7_socket->compression_buffer_length; 
    1352         total_size              = 0; 
    1353          
    1354         while(true) { 
    1355                 err = _wi_p7_socket_xflate_buffer(stream, compression, input, input_size, &input_processed, output, &output_size); 
     1352                return -1; 
     1353        } 
     1354         
     1355        return stream.total_out; 
     1356} 
     1357 
     1358 
     1359 
     1360static wi_integer_t _wi_p7_socket_inflate(wi_p7_socket_t *p7_socket, const void *in_buffer, uint32_t in_size) { 
     1361        z_stream                stream; 
     1362        wi_uinteger_t   multiple; 
     1363        int                             err, enderr; 
     1364         
     1365        for(multiple = 2; multiple < 16; multiple++) { 
     1366                p7_socket->compression_buffer_length = in_size * (1 << multiple); 
     1367 
     1368                if(!p7_socket->compression_buffer) 
     1369                        p7_socket->compression_buffer = wi_malloc(p7_socket->compression_buffer_length); 
     1370                else 
     1371                        p7_socket->compression_buffer = wi_realloc(p7_socket->compression_buffer, p7_socket->compression_buffer_length); 
     1372 
     1373                stream.zalloc           = Z_NULL; 
     1374                stream.zfree            = Z_NULL; 
     1375                stream.next_in          = (unsigned char *) in_buffer; 
     1376                stream.avail_in         = in_size; 
     1377                stream.next_out         = (unsigned char *) p7_socket->compression_buffer; 
     1378                stream.avail_out        = p7_socket->compression_buffer_length; 
     1379                 
     1380                err = inflateInit(&stream); 
    13561381                 
    13571382                if(err != Z_OK) { 
    …… 
    13611386                } 
    13621387                 
    1363                 total_size += output_size; 
    1364                  
    1365                 if(stream->avail_out > 0) 
    1366                         break; 
    1367                  
    1368                 p7_socket->compression_buffer_length *= 4; 
    1369                 p7_socket->compression_buffer = wi_realloc(p7_socket->compression_buffer, p7_socket->compression_buffer_length); 
    1370  
    1371                 offset                  = (output - p7_socket->compression_buffer) + output_size; 
    1372                 output                  = p7_socket->compression_buffer + offset; 
    1373                 output_size             = p7_socket->compression_buffer_length - offset; 
    1374                 input                   += input_processed; 
    1375                 input_size              -= input_processed; 
    1376                  
    1377                 if(compression == _WI_P7_SOCKET_DECOMPRESS && input_size == 0) 
    1378                         break; 
    1379         } 
    1380          
    1381         return total_size; 
    1382 } 
    1383  
    1384  
    1385  
    1386 static int _wi_p7_socket_xflate_buffer(z_stream *stream, _wi_p7_socket_compression_t compression, const void *input, uint32_t input_size, uint32_t *input_processed, void *output, uint32_t *output_size) { 
    1387         int             err; 
    1388  
    1389     stream->next_in             = (Bytef *) input; 
    1390     stream->avail_in    = input_size; 
    1391     stream->total_in    = 0; 
    1392  
    1393     stream->next_out    = output; 
    1394     stream->avail_out   = *output_size; 
    1395     stream->total_out   = 0; 
    1396          
    1397         if(compression == _WI_P7_SOCKET_COMPRESS) 
    1398                 err = deflate(stream, Z_SYNC_FLUSH); 
    1399         else 
    1400                 err = inflate(stream, Z_SYNC_FLUSH); 
    1401      
    1402         if(err == Z_OK) { 
    1403                 *input_processed        = stream->total_in; 
    1404                 *output_size            = stream->total_out; 
    1405         } 
    1406      
    1407         return err; 
     1388                err = inflate(&stream, Z_FINISH); 
     1389                enderr = inflateEnd(&stream); 
     1390                 
     1391                if(err == Z_STREAM_END) { 
     1392                        if(enderr != Z_BUF_ERROR) 
     1393                                break; 
     1394                } 
     1395                else if(err == Z_OK) { 
     1396                        err = Z_BUF_ERROR; 
     1397                } 
     1398        } 
     1399         
     1400        return stream.total_out; 
    14081401} 
    14091402 
    …… 
    14471440                return false; 
    14481441         
    1449         if(WI_P7_COMPRESSION_ENABLED(p7_socket->options)) { 
    1450                 if(!_wi_p7_socket_configure_compression_streams(p7_socket)) 
    1451                         return false; 
    1452         } 
    1453          
    14541442        if(WI_P7_CHECKSUM_ENABLED(p7_socket->options)) 
    14551443                _wi_p7_socket_configure_checksum(p7_socket); 
    …… 
    14831471        if(!_wi_p7_socket_accept_handshake(p7_socket, timeout, options)) 
    14841472                return false; 
    1485          
    1486         if(WI_P7_COMPRESSION_ENABLED(p7_socket->options)) { 
    1487                 if(!_wi_p7_socket_configure_compression_streams(p7_socket)) 
    1488                         return false; 
    1489         } 
    14901473         
    14911474        if(WI_P7_CHECKSUM_ENABLED(p7_socket->options)) 
    …… 
    16261609 
    16271610        if(p7_socket->compression_enabled) { 
    1628                 compressed_size = _wi_p7_socket_xcompress_buffer(p7_socket, 
    1629                                                                                                                  _WI_P7_SOCKET_COMPRESS, 
    1630                                                                                                                  send_buffer, 
    1631                                                                                                                  send_size); 
     1611                compressed_size = _wi_p7_socket_deflate(p7_socket, send_buffer, send_size); 
    16321612                 
    16331613                if(compressed_size < 0) 
    …… 
    17471727         
    17481728        if(p7_socket->compression_enabled) { 
    1749                 decompressed_size = _wi_p7_socket_xcompress_buffer(p7_socket, 
    1750                                                                                                                    _WI_P7_SOCKET_DECOMPRESS, 
    1751                                                                                                                    receive_buffer, 
    1752                                                                                                                    receive_size); 
     1729                decompressed_size = _wi_p7_socket_inflate(p7_socket, receive_buffer, receive_size); 
    17531730                 
    17541731                if(decompressed_size < 0)