API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 19th, 2011
184
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 13.08 KB | None | 0 0
raw download clone embed print report
  1.  /*=============================================================================
  2.  *
  3.  * Copyright (C) 2003, 2011 Alessandro Duca <alessandro.duca@gmail.com>
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Lesser General Public
  7.  * License as published by the Free Software Foundation; either
  8.  * version 2.1 of the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Lesser General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Lesser General Public
  16.  * License along with this library; if not, write to the Free Software
  17.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18.  *=============================================================================
  19.  */
  20.  
  21. #include "_yenc.h"
  22.  
  23. /* Typedefs */
  24. typedef struct {
  25.     uInt crc;
  26.     uLong bytes;
  27. } Crc32;
  28.  
  29. /* Declarations */
  30. static uInt crc_tab[256] = {
  31.     0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
  32.     0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
  33.     0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
  34.     0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
  35.     0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
  36.     0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
  37.     0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
  38.     0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
  39.     0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
  40.     0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
  41.     0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
  42.     0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
  43.     0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
  44.     0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
  45.     0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
  46.     0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
  47.     0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
  48.     0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
  49.     0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
  50.     0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
  51.     0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
  52.     0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
  53.     0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
  54.     0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
  55.     0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
  56.     0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
  57.     0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
  58.     0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
  59.     0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
  60.     0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
  61.     0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
  62.     0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
  63.     0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
  64.     0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
  65.     0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
  66.     0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
  67.     0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
  68.     0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
  69.     0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
  70.     0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
  71.     0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
  72.     0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
  73.     0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
  74. };
  75. static char* argnames[] = {"infile", "outfile", "bytez", NULL};
  76.  
  77. /* Function declarations */
  78. static void crc_init(Crc32 *, uInt);
  79. static void crc_update(Crc32 *, uInt);
  80. static Bool readable(FILE *);
  81. static Bool writable(FILE *);
  82. void init_yenc(void);
  83. static int encode_buffer(Byte *, Byte *, uInt, Crc32 *, uInt *);
  84. static int decode_buffer(Byte *, Byte *, uInt, Crc32 *, Bool *);
  85. PyObject* decode_string(PyObject* ,PyObject* ,PyObject* );
  86.  
  87. /* Python API requirements */
  88. static char encode_doc[] = "encode(input_file, output_file, <size>)";
  89. static char decode_doc[] = "decode(input_file, output_file, <size>)";
  90. static char encode_string_doc[] = "encode_string(string, crc32, column)";
  91. static char decode_string_doc[] = "decode_string(string, crc32, escape)";
  92. static PyMethodDef funcs[] = {
  93.         {"encode", (PyCFunction) encode_file, METH_KEYWORDS | METH_VARARGS, encode_doc},
  94.         {"decode", (PyCFunction) decode_file, METH_KEYWORDS | METH_VARARGS, decode_doc},
  95.         {"encode_string", (PyCFunction) encode_string, METH_KEYWORDS | METH_VARARGS, encode_string_doc},
  96.         {"decode_string", (PyCFunction) decode_string, METH_KEYWORDS | METH_VARARGS, decode_string_doc},
  97.         {NULL, NULL, 0, NULL}
  98. };
  99. /* Function definitions */
  100. static void crc_init(Crc32 *crc, uInt value)
  101. {
  102.     crc->crc = value;
  103.     crc->bytes = 0UL;
  104. }
  105.  
  106. static void crc_update(Crc32 *crc, uInt c)
  107. {
  108.     crc->crc=crc_tab[(crc->crc^c)&0xff]^((crc->crc>>8)&0xffffff);
  109.     crc->bytes++;
  110. }
  111.  
  112. /*
  113.  * Todo: provide alternatives for this to work on win32
  114.  */
  115. static Bool writable(FILE *file)
  116. {
  117.     int mode = fcntl(fileno(file),F_GETFL) & O_ACCMODE;
  118.     return (mode == O_WRONLY) || (mode == O_RDWR);
  119. }
  120.  
  121. static Bool readable(FILE *file)
  122. {
  123.     int mode = fcntl(fileno(file),F_GETFL) & O_ACCMODE;
  124.     return (mode == O_RDONLY) || (mode == O_RDWR);
  125. }
  126. /*
  127.  *
  128.  */
  129.  
  130. static int encode_buffer(
  131.         Byte *input_buffer,
  132.         Byte *output_buffer,
  133.         uInt bytes,
  134.         Crc32 *crc,
  135.         uInt *col
  136.         )
  137. {
  138.     uInt encoded;
  139.     uInt in_ind;
  140.     uInt out_ind;
  141.     Byte byte;
  142.        
  143.     out_ind = 0;
  144.     for(in_ind=0; in_ind < bytes; in_ind++) {
  145.         byte = (Byte)(input_buffer[in_ind] + 42);
  146.         crc_update(crc, input_buffer[in_ind]);
  147.         switch(byte){
  148.             case ZERO:
  149.             case LF:
  150.             case CR:
  151.             case ESC:
  152.                 goto escape_string;
  153.             case TAB:
  154.             case SPACE:
  155.                 if(*col == 0 || *col == LINESIZE-1) {
  156.                     goto escape_string;
  157.                 }
  158.                         case DOT:
  159.                                 if(*col == 0) {
  160.                                         goto escape_string;
  161.                                 }
  162.             default:
  163.                 goto plain_string;
  164.         }
  165.         escape_string:
  166.         byte = (Byte)(byte + 64);
  167.         output_buffer[out_ind++] = ESC;
  168.         (*col)++;
  169.         plain_string:
  170.         output_buffer[out_ind++] = byte;
  171.         (*col)++;
  172.         encoded++;
  173.         if(*col >= LINESIZE) {
  174.             output_buffer[out_ind++] = CR;
  175.             output_buffer[out_ind++] = LF;
  176.             *col = 0;
  177.         }
  178.     }
  179.     return out_ind;
  180. }
  181.  
  182. PyObject* encode_file(
  183.         PyObject* self,
  184.         PyObject* args,
  185.         PyObject* kwds
  186.         )
  187. {
  188.     Byte read_buffer[BLOCK];
  189.     Byte write_buffer[LONGBUFF];
  190.     uLong encoded = 0;
  191.     uInt col = 0;
  192.     uInt read_bytes;
  193.     uInt in_ind;
  194.     uInt encoded_bytes;
  195.     uLong bytes = 0;
  196.     Crc32 crc;
  197.  
  198.     FILE *infile = NULL, *outfile = NULL;
  199.     PyObject *Py_infile = NULL, *Py_outfile = NULL;
  200.    
  201.     if(!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!|l", argnames, \
  202.                 &PyFile_Type, &Py_infile, \
  203.                 &PyFile_Type, &Py_outfile, \
  204.                 &bytes)) return NULL;
  205.  
  206.     infile = PyFile_AsFile(Py_infile);
  207.     outfile = PyFile_AsFile(Py_outfile);
  208.    
  209.     if(!readable(infile) || !writable(outfile) ) {
  210.         return PyErr_Format(PyExc_ValueError, "file objects not writeable/readable");
  211.     }
  212.    
  213.     crc_init(&crc, 0xffffffffl);
  214.     while(encoded < bytes || bytes == 0){
  215.         if( bytes && (bytes - encoded) < BLOCK) {
  216.             in_ind = bytes - encoded;
  217.         } else {
  218.             in_ind = BLOCK;
  219.         }
  220.         read_bytes = fread(&read_buffer, 1, in_ind, infile);
  221.         if(read_bytes < 1) {
  222.                         break;
  223.                 }
  224.         encoded_bytes = encode_buffer(&read_buffer[0], &write_buffer[0], read_bytes, &crc, &col);
  225.         if(fwrite(&write_buffer, 1, encoded_bytes, outfile) != encoded_bytes) {
  226.             break;
  227.         }
  228.         encoded += read_bytes;
  229.     }
  230.     if(ferror(infile) || ferror(outfile)) {
  231.         return PyErr_Format(PyExc_IOError, "I/O Error while encoding");
  232.     }
  233.     if(col > 0) {
  234.         fputc(CR, outfile);
  235.         fputc(LF, outfile);
  236.     }
  237.     fflush(outfile);
  238.     return Py_BuildValue("(l,L)", encoded, (long long)crc.crc);
  239. }
  240.  
  241. static int decode_buffer(
  242.         Byte *input_buffer,
  243.         Byte *output_buffer,
  244.         uInt bytes,
  245.         Crc32 *crc,
  246.         Bool *escape
  247.         )
  248. {
  249.     uInt read_ind;
  250.     uInt decoded_bytes;
  251.     Byte byte;
  252.    
  253.     decoded_bytes = 0;
  254.     for(read_ind = 0; read_ind < bytes; read_ind++) {
  255.         byte = input_buffer[read_ind];
  256.         if(*escape) {
  257.             byte = (Byte)(byte - 106);
  258.             *escape = 0;
  259.         } else if(byte == ESC) {
  260.             *escape = 1;
  261.             continue;
  262.         } else if(byte == LF || byte == CR) {
  263.             continue;
  264.         } else {
  265.             byte = (Byte)(byte - 42);
  266.         }
  267.         output_buffer[decoded_bytes] = byte;
  268.         decoded_bytes++;
  269.         crc_update(crc, byte);
  270.     }
  271.     return decoded_bytes;
  272. }
  273.  
  274. PyObject* encode_string(
  275.         PyObject* self,
  276.         PyObject* args,
  277.         PyObject* kwds
  278.         )
  279. {
  280.     PyObject *Py_input_string;
  281.     PyObject *Py_output_string;
  282.     PyObject *retval;
  283.    
  284.     Byte *input_buffer = NULL;
  285.     Byte *output_buffer = NULL;
  286.     long long crc_value = 0xffffffffll;
  287.     uInt input_len = 0;
  288.     uInt output_len = 0;
  289.     uInt col = 0;
  290.     Crc32 crc;
  291.    
  292.     static char *kwlist[] = { "string", "crc32", "column", NULL };
  293.     if(!PyArg_ParseTupleAndKeywords(args,
  294.                 kwds,
  295.                 "O!|Li",
  296.                 kwlist,
  297.                 &PyBytes_Type,
  298.                 &Py_input_string,
  299.                 &crc_value,
  300.                 &col
  301.                 ))
  302.         return NULL;
  303.  
  304.     crc_init(&crc, (uInt)crc_value);
  305.     input_len = PyString_Size(Py_input_string);
  306.     input_buffer = (Byte *) PyString_AsString(Py_input_string);
  307.     output_buffer = (Byte *) malloc((2 * input_len / LINESIZE + 1) * (LINESIZE + 2));
  308.     output_len = encode_buffer(input_buffer, output_buffer, input_len, &crc, &col);
  309.     Py_output_string = PyString_FromStringAndSize((char *)output_buffer, output_len);
  310.     retval = Py_BuildValue("(S,L,i)", Py_output_string, (long long)crc.crc, col);
  311.  
  312.     free(output_buffer);
  313.     Py_DECREF(Py_output_string);
  314.    
  315.     return retval;
  316. }
  317.  
  318. PyObject* decode_file(
  319.         PyObject* self,
  320.         PyObject* args,
  321.         PyObject* kwds
  322.         )
  323. {
  324.     Byte read_buffer[BLOCK];
  325.     Byte write_buffer[LONGBUFF];
  326.     uLong decoded = 0;
  327.     uInt decoded_bytes;
  328.     uInt read_bytes;
  329.     uLong read_max;
  330.    
  331.     Bool escape = 0;
  332.     uLong bytes = 0;
  333.     Crc32 crc;
  334.  
  335.     FILE *infile = NULL, *outfile = NULL;
  336.     PyObject *Py_infile = NULL, *Py_outfile = NULL;
  337.    
  338.     if(!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!|l", argnames, \
  339.                 &PyFile_Type, &Py_infile, \
  340.                 &PyFile_Type, &Py_outfile, \
  341.                 &bytes)) return NULL;
  342.  
  343.     infile = PyFile_AsFile(Py_infile);
  344.     outfile = PyFile_AsFile(Py_outfile);
  345.  
  346.     if(!readable(infile) || !writable(outfile)) {
  347.         return PyErr_Format(PyExc_ValueError,
  348.                 "file objects not writeable/readable");
  349.     }
  350.  
  351.     crc_init(&crc, 0xffffffffl);
  352.     while(decoded < bytes || bytes == 0){
  353.         if(bytes){
  354.             read_max=(bytes-decoded)<BLOCK?(bytes-decoded):BLOCK;
  355.         } else {
  356.             read_max=BLOCK;
  357.         };
  358.         read_bytes = fread((Byte *)&read_buffer, 1, read_max, infile);
  359.         if(read_bytes == 0) break;
  360.         decoded_bytes = decode_buffer(&read_buffer[0],
  361.                 &write_buffer[0],read_bytes, &crc, &escape);
  362.         if(fwrite(&write_buffer[0],1,decoded_bytes,outfile)!=decoded_bytes){
  363.             break;
  364.         }
  365.         decoded += decoded_bytes;
  366.     }
  367.     if(ferror(infile) || ferror(outfile)) {
  368.         return PyErr_Format(PyExc_IOError, "I/O Error while decoding");
  369.     }
  370.     fflush(outfile);
  371.     return Py_BuildValue("(l,L)", decoded, (long long)crc.crc);
  372. }
  373.  
  374. PyObject* decode_string(
  375.         PyObject* self,
  376.         PyObject* args,
  377.         PyObject* kwds
  378.         )
  379. {
  380.     PyObject *Py_input_string;
  381.     PyObject *Py_output_string;
  382.     PyObject *retval;
  383.    
  384.     Byte *input_buffer = NULL;
  385.     Byte *output_buffer = NULL;
  386.     long long crc_value = 0xffffffffll;
  387.     uInt input_len = 0;
  388.     uInt output_len = 0;
  389.     int escape = 0;
  390.     Crc32 crc;
  391.    
  392.     static char *kwlist[] = { "string", "crc32", "escape", NULL };
  393.     if(!PyArg_ParseTupleAndKeywords(args,
  394.                 kwds,
  395.                 "O!|Li",
  396.                 kwlist,
  397.                 &PyBytes_Type,
  398.                 &Py_input_string,
  399.                 &crc_value,
  400.                 &escape
  401.                 ))
  402.         return NULL;
  403.     crc_init(&crc, (uInt)crc_value);
  404.     input_len = PyString_Size(Py_input_string);
  405.     input_buffer = (Byte *)PyString_AsString(Py_input_string);
  406.     output_buffer = (Byte *)malloc( input_len );
  407.     output_len = decode_buffer(input_buffer, output_buffer, input_len, &crc, &escape);
  408.     Py_output_string = PyString_FromStringAndSize((char *)output_buffer, output_len);
  409.     retval = Py_BuildValue("(S,L,i)", Py_output_string, (long long)crc.crc, escape);
  410.    
  411.     free(output_buffer);
  412.     Py_DECREF(Py_output_string);
  413.  
  414.     return retval;
  415. }
  416.  
  417.  
  418. void init_yenc()
  419. {
  420.     Py_InitModule3("_yenc", funcs, "Raw yenc operations");
  421. }
  422.  
  423.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!