मैं xml फ़ाइलों को xfdl (base64-gzip) में कैसे एन्कोड कर सकता हूं?

कुछ और पढ़ने से पहले, कृपया मूल धागा

अवलोकन: एक .xfdl फ़ाइल एक gzipped .xml फ़ाइल है जिसे बेस 64 में एन्कोड किया गया है। मैं .xfdl को xml में डी-एन्कोड करना चाहता हूं जिसे मैं संशोधित कर सकता हूं और फिर एक .xfdl फ़ाइल में फिर से एन्कोड कर सकता हूं।

xfdl > xml.gz > xml > xml.gz > xfdl

मैं एक .xfdl फ़ाइल लेने और uudeview का उपयोग कर बेस 64 से डी-एन्कोड करने में सक्षम हूं:

uudeview -i yourform.xfdl

फिर Gunzip का उपयोग कर इसे डिकंप्रेस किया

gunzip -S "" < UNKNOWN.001 > yourform-unpacked.xml

उत्पादित एक्सएमएल 100% पठनीय है और अद्भुत लग रहा है। xml को संशोधित किए बिना, मुझे gzip का उपयोग करके इसे फिर से संपीड़ित करने में सक्षम होना चाहिए:

gzip yourform-unpacked.xml

फिर बेस -64 में पुनः-एन्कोड किया गया:

base64 -e yourform-unpacked.xml.gz yourform_reencoded.xfdl

If my thinking is correct, the original file and the re-encoded file should be equal. If I put yourform.xfdl and yourform_reencoded.xfdl into beyond compare, however, they do not match up. Also, the original file can be viewed in an http://www.grants.gov/help/download_software.jsp#pureedge">.xfdl viewer. The viewer says that the re-encoded xfdl is unreadable.

मैंने बेस 64 में पुनः-एन्कोड करने के लिए यूनेव्यूव की भी कोशिश की है, यह भी वही परिणाम उत्पन्न करता है। किसी भी सहायता की सराहना की जाएगी।

0
ro fr bn

8 उत्तर

दिलचस्प है, मैं इसे एक शॉट दे दूँगा। हालात मामूली नहीं हैं, हालांकि। नई एन्कोडेड फ़ाइल अधिक है और पहले और बाद में बाइनरी की तुलना करते समय, डेटा शायद ही मेल खाता है।

पहले (पहली तीन पंक्तियां)

H4sIAAAAAAAAC+19eZOiyNb3/34K3r4RT/WEU40ssvTtrhuIuKK44Bo3YoJdFAFZ3D79C6hVVhUq
dsnUVN/qmIkSOLlwlt/JPCfJ/PGf9dwAlorj6pb58wv0LfcFUEzJknVT+/ml2uXuCSJP3kNf/vOQ
+TEsFVkgoDfdn18mnmd/B8HVavWt5TsKI2vKN8magyENiH3Lf9kRfpd817PmF+jpiOhQRFZcXTMV

के बाद (पहली तीन पंक्तियां):

H4sICJ/YnEgAAzEyNDQ2LTExNjk2NzUueGZkbC54bWwA7D1pU+JK19/9FV2+H5wpByEhJMRH
uRUgCMom4DBYt2oqkAZyDQlmQZ1f/3YSNqGzKT3oDH6RdE4vOXuf08vFP88TFcygYSq6dnlM
naWOAdQGuqxoo8vjSruRyGYzfII6/id3dPGjVKwCBK+Zl8djy5qeJ5NPT09nTduAojyCZwN9

जैसा कि आप H4SI मिलान कर सकते हैं, उसके बाद यह पंडोनियम है।

0
जोड़ा
लेकिन जब तक आप एक ही जीजीआईपी कार्यान्वयन का उपयोग नहीं करते हैं, तो आप केवल एच 4 एसआई की अपेक्षा करते हैं। "पंडोनियम" सामान्य है :-)
जोड़ा लेखक Rory Alsop, स्रोत

Gzip एल्गोरिदम के विभिन्न कार्यान्वयन हमेशा थोड़ा अलग होते हैं लेकिन फिर भी सही फाइलें, मूल फ़ाइल का संपीड़न स्तर अलग-अलग हो सकता है, फिर आप इसे किस प्रकार चला रहे हैं।

0
जोड़ा

जहां तक ​​मुझे पता है कि आप पहले से संपीड़ित फ़ाइल का संपीड़न स्तर नहीं ढूंढ सकते हैं। जब आप फ़ाइल को संपीड़ित कर रहे हैं तो आप संपीड़न स्तर को निर्दिष्ट कर सकते हैं - # जहां # 1 से 9 तक है (1 सबसे तेज़ संपीड़न और 9 सबसे संकुचित फ़ाइल है)। प्रैक्टिस में आपको किसी संपीड़ित फ़ाइल की तुलना कभी नहीं की जानी चाहिए जिसे निकाला गया है और फिर से दबाया गया है, मामूली विविधता आसानी से फसल हो सकती है। आपके मामले में मैं gzip'd संस्करणों के बजाय बेस 64 एन्कोडेड संस्करणों की तुलना करूंगा।

0
जोड़ा

आपको XFDL फ़ाइल की शुरुआत में निम्न पंक्ति डालना होगा:

आवेदन / vnd.xfdl; सामग्री एन्कोडिंग = "बेस 64-gzip"

बेस 64-एन्कोडेड फ़ाइल जेनरेट करने के बाद, इसे एक टेक्स्ट एडिटर में खोलें और ऊपर की रेखा को पहले पंक्ति पर पेस्ट करें। सुनिश्चित करें कि बेस 64'एड ब्लॉक दूसरी पंक्ति की शुरुआत में शुरू होता है।

इसे सहेजें और दर्शक में आज़माएं! यदि यह अभी भी काम नहीं करता है, तो हो सकता है कि एक्सएमएल में किए गए परिवर्तन इसे किसी भी तरह से अनुपालन न करें। इस मामले में, एक्सएमएल को संशोधित करने के बाद, लेकिन इससे पहले कि इसे gzipped और base64 एन्कोड किया गया हो, इसे एक .xfdl फ़ाइल एक्सटेंशन से सहेजें और इसे व्यूअर टूल के साथ खोलने का प्रयास करें। दर्शक को असम्पीडित / अनएन्कोडेड फ़ाइल को पार्स और प्रदर्शित करने में सक्षम होना चाहिए यदि यह वैध XFDL प्रारूप में है।

0
जोड़ा

gzip फ़ाइल नाम के फ़ाइल में फ़ाइल नाम डाल देगा, ताकि असम्पीडित फ़ाइल के फ़ाइल नाम के आधार पर एक gzipped फ़ाइल लंबाई में भिन्न हो।

यदि gzip किसी स्ट्रीम पर कार्य करता है, तो फ़ाइल नाम छोड़ा जाता है और फ़ाइल थोड़ी कम होती है, इसलिए निम्न कार्य करना चाहिए:

gzip yourform-unpacked.xml.gz

फिर बेस -64 में पुनः-एन्कोड किया गया: base64 -e yourform-unpacked.xml.gz yourform_reencoded.xfdl

शायद यह एक ही लंबाई की एक फाइल का उत्पादन करेगा

0
जोड़ा

इन्हें जांचें:

http://www.ourada.org/blog/archives/375

http://www.ourada.org/blog/archives/390

वे पाइथन में हैं, रूबी नहीं, लेकिन आपको बहुत करीब मिलना चाहिए।

और एल्गोरिदम वास्तव में 'एप्लिकेशन / vnd.xfdl' के बजाय हेडर 'एप्लिकेशन / x-xfdl; सामग्री-एन्कोडिंग = "asc-gzip" फ़ाइलों वाली फ़ाइलों के लिए है; सामग्री एन्कोडिंग = "बेस 64-gzip" ' लेकिन अच्छी खबर यह है कि PureEdge (उर्फ आईबीएम कमल फॉर्म) उस प्रारूप को बिना किसी समस्या के खुलेंगे।

फिर इसे ऊपर करने के लिए, यहां बेस 64-गीज़िप डीकोड (पायथन में) है ताकि आप पूर्ण राउंड-ट्रिप कर सकें:

with open(filename, 'r') as f:
  header = f.readline()
  if header == 'application/vnd.xfdl; content-encoding="base64-gzip"\n':
    decoded = b''
    for line in f:
      decoded += base64.b64decode(line.encode("ISO-8859-1"))
    xml = zlib.decompress(decoded, zlib.MAX_WBITS + 16)
0
जोड़ा
(यह मेरा ब्लॉग नहीं है, बीटीडब्लू।) और उस MAX_WBITS जादू के लिए क्रेडिट: stackoverflow.com/questions/1838699/…
जोड़ा लेखक CrazyPyro, स्रोत

मैंने इसे http://iharder.net/base64 से बेस 64 कक्षा की सहायता से जावा में किया था।

मैं जावा में फॉर्म मैनिपुलेशन करने के लिए एक आवेदन पर काम कर रहा हूं। मैं फ़ाइल को डीकोड करता हूं, एक्सएमएल से एक डोम दस्तावेज़ बना देता हूं और फिर उसे फाइल पर लिखता हूं।

फ़ाइल को पढ़ने के लिए जावा में मेरा कोड इस तरह दिखता है:

public XFDLDocument(String inputFile) 
        throws IOException, 
            ParserConfigurationException,
            SAXException

{
    fileLocation = inputFile;

    try{

        //create file object
        File f = new File(inputFile);
        if(!f.exists()) {
            throw new IOException("Specified File could not be found!");
        }

        //open file stream from file
        FileInputStream fis = new FileInputStream(inputFile);

        //Skip past the MIME header
        fis.skip(FILE_HEADER_BLOCK.length());   

        //Decompress from base 64                   
        Base64.InputStream bis = new Base64.InputStream(fis, 
                Base64.DECODE);

        //UnZIP the resulting stream
        GZIPInputStream gis = new GZIPInputStream(bis);

        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder db = dbf.newDocumentBuilder();
        doc = db.parse(gis);

        gis.close();
        bis.close();
        fis.close();

    }
    catch (ParserConfigurationException pce) {
        throw new ParserConfigurationException("Error parsing XFDL from file.");
    }
    catch (SAXException saxe) {
        throw new SAXException("Error parsing XFDL into xml Document.");
    }
}

जावा में मेरा कोड डिस्क पर फ़ाइल लिखने के लिए ऐसा लगता है:

    /**
     * Saves the current document to the specified location
     * @param destination Desired destination for the file.
     * @param asXML True if output needs should be as un-encoded xml not Base64/GZIP
     * @throws IOException File cannot be created at specified location
     * @throws TransformerConfigurationExample
     * @throws TransformerException 
     */
    public void saveFile(String destination, boolean asXML) 
        throws IOException, 
            TransformerConfigurationException, 
            TransformerException  
        {

        BufferedWriter bf = new BufferedWriter(new FileWriter(destination));
        bf.write(FILE_HEADER_BLOCK);
        bf.newLine();
        bf.flush();
        bf.close();

        OutputStream outStream;
        if(!asXML) {
            outStream = new GZIPOutputStream(
                new Base64.OutputStream(
                        new FileOutputStream(destination, true)));
        } else {
            outStream = new FileOutputStream(destination, true);
        }

        Transformer t = TransformerFactory.newInstance().newTransformer();
        t.transform(new DOMSource(doc), new StreamResult(outStream));

        outStream.flush();
        outStream.close();      
    }

उम्मीद है की वो मदद करदे।

0
जोड़ा

मैं इस तरह कुछ पर काम कर रहा हूं और यह PHP के लिए काम करना चाहिए। आपके पास एक लिखने योग्य टीएमपी फ़ोल्डर होना चाहिए और PHP फ़ाइल को example.php नाम दिया जाना चाहिए!

    <?php
    function gzdecode($data) {
        $len = strlen($data);
        if ($len < 18 || strcmp(substr($data,0,2),"\x1f\x8b")) {
            echo "FILE NOT GZIP FORMAT";
            return null;  // Not GZIP format (See RFC 1952)
        }
        $method = ord(substr($data,2,1));  // Compression method
        $flags  = ord(substr($data,3,1));  // Flags
        if ($flags & 31 != $flags) {
            // Reserved bits are set -- NOT ALLOWED by RFC 1952
            echo "RESERVED BITS ARE SET. VERY BAD";
            return null;
        }
        // NOTE: $mtime may be negative (PHP integer limitations)
        $mtime = unpack("V", substr($data,4,4));
        $mtime = $mtime[1];
        $xfl   = substr($data,8,1);
        $os    = substr($data,8,1);
        $headerlen = 10;
        $extralen  = 0;
        $extra     = "";
        if ($flags & 4) {
            // 2-byte length prefixed EXTRA data in header
            if ($len - $headerlen - 2 < 8) {
                return false;    // Invalid format
                echo "INVALID FORMAT";
            }
            $extralen = unpack("v",substr($data,8,2));
            $extralen = $extralen[1];
            if ($len - $headerlen - 2 - $extralen < 8) {
                return false;    // Invalid format
                echo "INVALID FORMAT";
            }
            $extra = substr($data,10,$extralen);
            $headerlen += 2 + $extralen;
        }

        $filenamelen = 0;
        $filename = "";
        if ($flags & 8) {
            // C-style string file NAME data in header
            if ($len - $headerlen - 1 < 8) {
                return false;    // Invalid format
                echo "INVALID FORMAT";
            }
            $filenamelen = strpos(substr($data,8+$extralen),chr(0));
            if ($filenamelen === false || $len - $headerlen - $filenamelen - 1 < 8) {
                return false;    // Invalid format
                echo "INVALID FORMAT";
            }
            $filename = substr($data,$headerlen,$filenamelen);
            $headerlen += $filenamelen + 1;
        }

        $commentlen = 0;
        $comment = "";
        if ($flags & 16) {
            // C-style string COMMENT data in header
            if ($len - $headerlen - 1 < 8) {
                return false;    // Invalid format
                echo "INVALID FORMAT";
            }
            $commentlen = strpos(substr($data,8+$extralen+$filenamelen),chr(0));
            if ($commentlen === false || $len - $headerlen - $commentlen - 1 < 8) {
                return false;    // Invalid header format
                echo "INVALID FORMAT";
            }
            $comment = substr($data,$headerlen,$commentlen);
            $headerlen += $commentlen + 1;
        }

        $headercrc = "";
        if ($flags & 1) {
            // 2-bytes (lowest order) of CRC32 on header present
            if ($len - $headerlen - 2 < 8) {
                return false;    // Invalid format
                echo "INVALID FORMAT";
            }
            $calccrc = crc32(substr($data,0,$headerlen)) & 0xffff;
            $headercrc = unpack("v", substr($data,$headerlen,2));
            $headercrc = $headercrc[1];
            if ($headercrc != $calccrc) {
                echo "BAD CRC";
                return false;    // Bad header CRC
            }
            $headerlen += 2;
        }

        // GZIP FOOTER - These be negative due to PHP's limitations
        $datacrc = unpack("V",substr($data,-8,4));
        $datacrc = $datacrc[1];
        $isize = unpack("V",substr($data,-4));
        $isize = $isize[1];

        // Perform the decompression:
        $bodylen = $len-$headerlen-8;
        if ($bodylen < 1) {
            // This should never happen - IMPLEMENTATION BUG!
            echo "BIG OOPS";
            return null;
        }
        $body = substr($data,$headerlen,$bodylen);
        $data = "";
        if ($bodylen > 0) {
            switch ($method) {
                case 8:
                    // Currently the only supported compression method:
                    $data = gzinflate($body);
                    break;
                default:
                    // Unknown compression method
                    echo "UNKNOWN COMPRESSION METHOD";
                return false;
            }
        } else {
            // I'm not sure if zero-byte body content is allowed.
            // Allow it for now...  Do nothing...
            echo "ITS EMPTY";
        }

        // Verifiy decompressed size and CRC32:
        // NOTE: This may fail with large data sizes depending on how
        //       PHP's integer limitations affect strlen() since $isize
        //       may be negative for large sizes.
        if ($isize != strlen($data) || crc32($data) != $datacrc) {
            // Bad format!  Length or CRC doesn't match!
            echo "LENGTH OR CRC DO NOT MATCH";
            return false;
        }
        return $data;
    }
    echo "<html><head></head><body>";
    if (empty($_REQUEST['upload'])) {
        echo <<<_END
    <form enctype="multipart/form-data" action="example.php" method="POST">
    <input type="hidden" name="MAX_FILE_SIZE" value="100000" />
    <table>
    <th>
    <input name="uploadedfile" type="file" />
    </th>
    <tr>
    <td><input type="submit" name="upload" value="Convert File" /></td>
    </tr>
    </table>
    </form>
    _END;

    }
    if (!empty($_REQUEST['upload'])) {
        $file           = "tmp/" . $_FILES['uploadedfile']['name'];
        $orgfile        = $_FILES['uploadedfile']['name'];
        $name           = str_replace(".xfdl", "", $orgfile);
        $convertedfile  = "tmp/" . $name . ".xml";
        $compressedfile = "tmp/" . $name . ".gz";
        $finalfile      = "tmp/" . $name . "new.xfdl";
        $target_path    = "tmp/";
        $target_path    = $target_path . basename($_FILES['uploadedfile']['name']);
        if (move_uploaded_file($_FILES['uploadedfile']['tmp_name'], $target_path)) {
        } else {
            echo "There was an error uploading the file, please try again!";
        }
        $firstline      = "application/vnd.xfdl; content-encoding=\"base64-gzip\"\n";
        $data           = file($file);
        $data           = array_slice($data, 1);
        $raw            = implode($data);
        $decoded        = base64_decode($raw);
        $decompressed   = gzdecode($decoded);
        $compressed     = gzencode($decompressed);
        $encoded        = base64_encode($compressed);
        $decoded2       = base64_decode($encoded);
        $decompressed2  = gzdecode($decoded2);
        $header         = bin2hex(substr($decoded, 0, 10));
        $tail           = bin2hex(substr($decoded, -8));
        $header2        = bin2hex(substr($compressed, 0, 10));
        $tail2          = bin2hex(substr($compressed, -8));
        $header3        = bin2hex(substr($decoded2, 0, 10));
        $tail3          = bin2hex(substr($decoded2, -8));
        $filehandle     = fopen($compressedfile, 'w');
        fwrite($filehandle, $decoded);
        fclose($filehandle);
        $filehandle     = fopen($convertedfile, 'w');
        fwrite($filehandle, $decompressed);
        fclose($filehandle);
        $filehandle     = fopen($finalfile, 'w');
        fwrite($filehandle, $firstline);
        fwrite($filehandle, $encoded);
        fclose($filehandle);
        echo "
"; echo "<table style='text-align:center' >"; echo "<tr><th>Stage 1</th>"; echo "<th>Stage 2</th>"; echo "<th>Stage 3</th></tr>"; echo "<tr><td>RAW DATA -></td><td>DECODED DATA -></td><td>UNCOMPRESSED DATA -></td></tr>"; echo "<tr><td>LENGTH: ".strlen($raw)."</td>"; echo "<td>LENGTH: ".strlen($decoded)."</td>"; echo "<td>LENGTH: ".strlen($decompressed)."</td></tr>"; echo "<tr><td>ORIGINAL</td><td>GZIP HEADER:".$header."</td><td>XML CONVERTED</td></tr>"; echo "<tr><td></td><td>GZIP TAIL:".$tail."</td><td></td></tr>"; echo "<tr><td> </td>"; echo "<td> </td>"; echo "<td> </td></tr>"; echo "<tr><th>Stage 6</th>"; echo "<th>Stage 5</th>"; echo "<th>Stage 4</th></tr>"; echo "<tr><td>ENCODED DATA <-</td><td>COMPRESSED DATA <-</td><td>UNCOMPRESSED DATA <-</td></tr>"; echo "<tr><td>LENGTH: ".strlen($encoded)."</td>"; echo "<td>LENGTH: ".strlen($compressed)."</td>"; echo "<td>LENGTH: ".strlen($decompressed)."</td></tr>"; echo "<tr><td></td><td>GZIP HEADER:".$header2."</td><td></td></tr>"; echo "<tr><td></td><td>GZIP TAIL:".$tail2."</td><td></td></tr>"; echo "<tr><td>FINAL FILE</td><td>RE-COMPRESSED FILE</td><td></td></tr>"; echo "<tr><td> </td>"; echo "<td> </td>"; echo "<td> </td></tr>"; echo "</table>"; echo "
";
    }
    echo "</body></html>";
    ?>
0
जोड़ा