Partage
  • Partager sur Facebook
  • Partager sur Twitter

[C] Zip et Unzip

Comment traiter les archives?

Sujet résolu
    17 février 2009 à 20:21:49

    Bonsoir à tous!

    Pour un de mes projets, j'ai besoin de télécharger plusieurs dizaines de fichiers situés sur un serveur distant.
    Pour le soulager en nombre de requete, il ne va envoyer qu'un seul fichier, une archive au format zip (php sait très bien faire des fichiers zip).
    Maintenant le problème est que je n'ai pas trouvé d'équivalent des fonctions de php en C pour traiter les fichiers zip. Je n'arrive donc pas à décompresser mon archive et du coup pas à récupérer et utiliser mes fichiers.

    Savez vous quelle lib utiliser? (j'ai bien cherché du côté de glib, zlib et compagnie, mais je ne comprend pas comment on les utilise)

    Merci!
    • Partager sur Facebook
    • Partager sur Twitter
      18 février 2009 à 8:21:03

      Bonjour!
      Je viens de tomber la dessus, c'est en anglais bien sûr! Mais je crois que sa pourrait t'intéresser.
      si t'as des question, hésite pas!
      a+!
      • Partager sur Facebook
      • Partager sur Twitter
        18 février 2009 à 10:59:56

        salut,

        il te faut la zip.lib.php que j'ai listée ci dessous. Ensuite une page d'exemple que j'ai faite il y a un moment, donc ASIS. C'est juste pour exposer le principe, mais je viens de la tester, est est fonctionnelle. Il ne faut pas perdre de vue que le serveur fabrique le zip dans sa ram, donc ne pas exagérer sur la taille, surtout si le serveur est très sollicité. Bonne chance.

        le fichier zip.lib.php
        <?php
        /* $Id: zip.lib.php,v 2.4 2004/11/03 13:56:52 garvinhicking Exp $ */
        // vim: expandtab sw=4 ts=4 sts=4:
        
        
        /**
         * Zip file creation class.
         * Makes zip files.
         *
         * Based on :
         *
         *  http://www.zend.com/codex.php?id=535&single=1
         *  By Eric Mueller <eric@themepark.com>
         *
         *  http://www.zend.com/codex.php?id=470&single=1
         *  by Denis125 <webmaster@atlant.ru>
         *
         *  a patch from Peter Listiak <mlady@users.sourceforge.net> for last modified
         *  date and time of the compressed file
         *
         * Official ZIP file format: http://www.pkware.com/appnote.txt
         *
         * @access  public
         */
        class zipfile
        {
            /**
             * Array to store compressed data
             *
             * @var  array    $datasec
             */
            var $datasec      = array();
        
            /**
             * Central directory
             *
             * @var  array    $ctrl_dir
             */
            var $ctrl_dir     = array();
        
            /**
             * End of central directory record
             *
             * @var  string   $eof_ctrl_dir
             */
            var $eof_ctrl_dir = "\x50\x4b\x05\x06\x00\x00\x00\x00";
        
            /**
             * Last offset position
             *
             * @var  integer  $old_offset
             */
            var $old_offset   = 0;
        
        
            /**
             * Converts an Unix timestamp to a four byte DOS date and time format (date
             * in high two bytes, time in low two bytes allowing magnitude comparison).
             *
             * @param  integer  the current Unix timestamp
             *
             * @return integer  the current date in a four byte DOS format
             *
             * @access private
             */
            function unix2DosTime($unixtime = 0) {
                $timearray = ($unixtime == 0) ? getdate() : getdate($unixtime);
        
                if ($timearray['year'] < 1980) {
                    $timearray['year']    = 1980;
                    $timearray['mon']     = 1;
                    $timearray['mday']    = 1;
                    $timearray['hours']   = 0;
                    $timearray['minutes'] = 0;
                    $timearray['seconds'] = 0;
                } // end if
        
                return (($timearray['year'] - 1980) << 25) | ($timearray['mon'] << 21) | ($timearray['mday'] << 16) |
                        ($timearray['hours'] << 11) | ($timearray['minutes'] << 5) | ($timearray['seconds'] >> 1);
            } // end of the 'unix2DosTime()' method
        
        
            /**
             * Adds "file" to archive
             *
             * @param  string   file contents
             * @param  string   name of the file in the archive (may contains the path)
             * @param  integer  the current timestamp
             *
             * @access public
             */
            function addFile($data, $name, $time = 0)
            {
                $name     = str_replace('\\', '/', $name);
        
                $dtime    = dechex($this->unix2DosTime($time));
                $hexdtime = '\x' . $dtime[6] . $dtime[7]
                          . '\x' . $dtime[4] . $dtime[5]
                          . '\x' . $dtime[2] . $dtime[3]
                          . '\x' . $dtime[0] . $dtime[1];
                eval('$hexdtime = "' . $hexdtime . '";');
        
                $fr   = "\x50\x4b\x03\x04";
                $fr   .= "\x14\x00";            // ver needed to extract
                $fr   .= "\x00\x00";            // gen purpose bit flag
                $fr   .= "\x08\x00";            // compression method
                $fr   .= $hexdtime;             // last mod time and date
        
                // "local file header" segment
                $unc_len = strlen($data);
                $crc     = crc32($data);
                $zdata   = gzcompress($data);
                $zdata   = substr(substr($zdata, 0, strlen($zdata) - 4), 2); // fix crc bug
                $c_len   = strlen($zdata);
                $fr      .= pack('V', $crc);             // crc32
                $fr      .= pack('V', $c_len);           // compressed filesize
                $fr      .= pack('V', $unc_len);         // uncompressed filesize
                $fr      .= pack('v', strlen($name));    // length of filename
                $fr      .= pack('v', 0);                // extra field length
                $fr      .= $name;
        
                // "file data" segment
                $fr .= $zdata;
        
                // "data descriptor" segment (optional but necessary if archive is not
                // served as file)
                // nijel(2004-10-19): this seems not to be needed at all and causes
                // problems in some cases (bug #1037737)
                //$fr .= pack('V', $crc);                 // crc32
                //$fr .= pack('V', $c_len);               // compressed filesize
                //$fr .= pack('V', $unc_len);             // uncompressed filesize
        
                // add this entry to array
                $this -> datasec[] = $fr;
        
                // now add to central directory record
                $cdrec = "\x50\x4b\x01\x02";
                $cdrec .= "\x00\x00";                // version made by
                $cdrec .= "\x14\x00";                // version needed to extract
                $cdrec .= "\x00\x00";                // gen purpose bit flag
                $cdrec .= "\x08\x00";                // compression method
                $cdrec .= $hexdtime;                 // last mod time & date
                $cdrec .= pack('V', $crc);           // crc32
                $cdrec .= pack('V', $c_len);         // compressed filesize
                $cdrec .= pack('V', $unc_len);       // uncompressed filesize
                $cdrec .= pack('v', strlen($name) ); // length of filename
                $cdrec .= pack('v', 0 );             // extra field length
                $cdrec .= pack('v', 0 );             // file comment length
                $cdrec .= pack('v', 0 );             // disk number start
                $cdrec .= pack('v', 0 );             // internal file attributes
                $cdrec .= pack('V', 32 );            // external file attributes - 'archive' bit set
        
                $cdrec .= pack('V', $this -> old_offset ); // relative offset of local header
                $this -> old_offset += strlen($fr);
        
                $cdrec .= $name;
        
                // optional extra field, file comment goes here
                // save to central directory
                $this -> ctrl_dir[] = $cdrec;
            } // end of the 'addFile()' method
        
        
            /**
             * Dumps out file
             *
             * @return  string  the zipped file
             *
             * @access public
             */
            function file()
            {
                $data    = implode('', $this -> datasec);
                $ctrldir = implode('', $this -> ctrl_dir);
        
                return
                    $data .
                    $ctrldir .
                    $this -> eof_ctrl_dir .
                    pack('v', sizeof($this -> ctrl_dir)) .  // total # of entries "on this disk"
                    pack('v', sizeof($this -> ctrl_dir)) .  // total # of entries overall
                    pack('V', strlen($ctrldir)) .           // size of central dir
                    pack('V', strlen($data)) .              // offset to start of central dir
                    "\x00\x00";                             // .zip file comment length
            } // end of the 'file()' method
        
        } // end of the 'zipfile' class
        ?>
        


        le fichier d'exemple
        <html><head>
        
        <script language="javascript">
        
        var msie = window.navigator.userAgent.toLowerCase().indexOf("msie") + 1;
        
        function ConfCheckers(formular,flag)
        {
            _bigstr = "";
            _limit = document.getElementsByName("checker").length;
            for (_idx = 0; _idx < _limit; _idx++)
            {
                switch(flag)
                {
                    case 1:
                        document.getElementsByName("checker")[_idx].checked = true;
                        break;
                    case 2:
                        document.getElementsByName("checker")[_idx].checked = !(document.getElementsByName("checker")[_idx].checked);
                        break;
                    default:
                        document.getElementsByName("checker")[_idx].checked = false;
                        break;
                }
            }
        }
        
        function SendZipRequest()
        {
            var _fileslist = new Array();
            _limit = document.getElementsByName("checker").length;
            for (_idx = 0; _idx < _limit; _idx++)
            {
                if(document.getElementsByName("checker")[_idx].checked)
                {
                    _fileslist.push(document.getElementsByName("checker")[_idx].value);
        
                }
            }
            if (_fileslist.length)
            {
                _bigstr = _fileslist.join(',');
                document.location = 'answerer.php?params=' + _bigstr;
            }
            else
            {
                alert("No file selected!");
            }
        }
        
        </script>
        
        <?
        
        function DoGrid($mylist, $mycolumns)
        {
            $_html_text = "";
            $_mylist = sizeof($mylist);
            $_lines = intval($_mylist / 4);
            if ($_mylist %  $mycolumns)
            {
                $_lines += 1;
            }
            $_max = $_lines * $mycolumns;
            if (!(sizeof($mylist) % 4))
            {
                $_max += 1;
            }
            $_end = sizeof($mylist);
            $_last_row = $mycolumns - 1;
            $_html_text =   '<table border="0">'."\n";
            for($_idx = 0; $_idx < $_max; $_idx++)
            {
                // start of the row
                if (!($_idx%$mycolumns))
                {
                    $_html_text .= "<tr>\n";
                }
                // cell has something in
                if ($_idx < $_end)
                {
                    $_html_text .= '<td>'.$mylist[$_idx] .'</td>'."\n";
                }
                // cell is empty
                else
                {
                    $_html_text .= '<td> </td>'."\n";
                }
                // end of the row
                if (($_idx == $_last_row))
                {
                    $_html_text .= "</tr>\n";
                }
            }
            $_html_text .= '</table>'."\n";
            return $_html_text;
        }
        
        function GetFilenames($mypath)
        {
            if(!is_dir($mypath))
            {
                echo "</head><body>$mypath is not a valid folder</body></html>";
                die();
            }
            else
            {
                $_list = array();
                if ($_handle = opendir($mypath))
                {
                    while (false !== ($_file = readdir($_handle))) {
                        if (is_file($mypath.$_file))
                        {
                            if($_file != "index.htm")
                            {
                                $_list[] = "\"$_file\"";
                            }
                        }
                    }
                    closedir($_handle);
                }
            }
            return join(",",$_list);
        }
        
        function GetChecker($filename,$chemin)
        {
            $_fullname = $chemin.$filename;
            $_html_text = '<input type="checkbox" name="checker" id="' . $_fullname . '" value="' . $_fullname . '"/>'.$filename;
            return $_html_text;
        }
        
        function GetCheckers($chemin)
        {
            $_filenames  = split(",",GetFilenames($chemin));
            $_html_text = "<h2>Files of \"$chemin\"</h2>\n";
            $_list_fn = array();
            foreach ($_filenames as $_filename)
            {
                $_filename = str_replace('"',"",$_filename);
                $_list_fn[] = GetChecker($_filename,$chemin);
            }
            $_html_text .= DoGrid($_list_fn, 4);
            return $_html_text;
        }
        
        function GetDownloadPage($list_dirs)
        {
            $_html_text = "";
            $_html_text .= '<input type="button" value="CLEAR ALL" onclick="ConfCheckers(this.form,0)" />'."\n";
            $_html_text .= '<input type="button" value="SELECT ALL" onclick="ConfCheckers(this.form,1)" />';
            $_html_text .= '<input type="button" value="REVERSE ALL" onclick="ConfCheckers(this.form,2)" />';
            $_html_text .= '<input type="button" value="DO the ZIP!" onclick="SendZipRequest()" /> '."<br/>\n";
            foreach ($list_dirs as $_chemin)
            {
                $_dir = str_replace('"',"",$_chemin);
                $_html_text .= GetCheckers($_dir);
            }
            return $_html_text;
        }
        
        ?>
        
        </head><body>
        
        <h1> ZIP on the fly</h1>
        Curiously, this snippet doesn't work with current directory ("" or "./")... :o(
         The size of the zipfile is only limited by the server memory. As the archive is virtual, (in memory, not stored on hard disk),
         it's not possible to build an archive with dozens of mp3, for instance.
        <br/><br/>
        
        <center>
        
        <?
        // creation du formulaire
        echo GetDownloadPage(array("img/","copy/","vrac/"));
        ?>
         
        </center>
        
        </body></html>
        


        EDIT:

        Désolé, je viens de relire et de comprendre que tu voulais dezipper en C...
        • Partager sur Facebook
        • Partager sur Twitter
          18 février 2009 à 23:30:02

          silversailsailor : je vais regarder. J'étais deja tombé sur ce site, mais je n'avais pas réussi à faire fonctionner leur .c et .h

          pfeuh : merci quand même ;)

          Je cherche une fonction qui prend en paramètre le nom de l'archive et un dossier de destination. Genre : Unzip("archive.zip","/fichiers décompressés/");
          • Partager sur Facebook
          • Partager sur Twitter
            22 février 2009 à 14:52:41

            je crois que Zlib le fait tres bien
            • Partager sur Facebook
            • Partager sur Twitter
              22 février 2009 à 14:59:07

              en effet, en matière d'archives, la zlib peut le faire.


              Ou alors, limite, tu regroupes tous tes fichiers dans un seul gros fichier, et ensuite tu le compresse(voir les exos en C++) et ensuite quand il arrive sur l'ordi du client, il le décompresse et sépare les fichiers de l'archive(avec un système que je te laisse le soin de prendre)
              • Partager sur Facebook
              • Partager sur Twitter
                23 février 2009 à 22:37:44

                C'est bien ce systeme là où je vous demande de m'aider!
                Je n'arrive pas à décompresser des zip en C!
                • Partager sur Facebook
                • Partager sur Twitter
                  24 février 2009 à 12:06:44

                  J'ai une solution alternative qui est cetrainement beaucoup moins intéressante que d'étudier un peu la Zlib. En fait celle-ci reviendrait à décompresser une archive rar avec "unrar.exe". Je ne sais pas si tu peux envoyer une archive rar avec ton script php mais je pense qu'il ne devrait pas y avoir de soucis pour cela. La décompression se fait alors très facilement en appelant unrar.exe en lui envoyant quelques paramètres sur le fichier à décompresser, l'action que tu veux faire, l'endroit où décompresser etc,...

                  Cette solution est rapide à implémenter mais bon... elle reste peu intéressante. Si tu veux plus d'infos ( par exemple où trouver le unrar.exe, où comment l'utiliser ( même si cela reste très facile ) ) fait moi signe =)
                  • Partager sur Facebook
                  • Partager sur Twitter
                    24 février 2009 à 22:48:49

                    Ce unrar, il est présent par défaut sur tous les ordinateurs, au moins windows?
                    Sinon c'est pas top comme solution.
                    • Partager sur Facebook
                    • Partager sur Twitter
                      24 février 2009 à 22:50:27

                      unrar n'est pas présent sur les ordis par défaut.

                      Pourquoi zlib te gene t elle ? Que ne comprends tu pas dedans ?
                      (Je ne me sers pas beaucoup de zlib mais il me semble que ce n'est pas si compliqué, enfin je peux me tromper !)
                      • Partager sur Facebook
                      • Partager sur Twitter

                      Recueil de code C et C++  http://fvirtman.free.fr/recueil/index.html

                        24 février 2009 à 23:06:39

                        Je n'ai pas réussi à l'utiliser pour décompresser un zip.
                        Je suis sooit pas doué, soit j'ai pas cherché au bon endroit.
                        C'est d'ailleurs pour cela que je me tourne vers ce forum.

                        Tu l'utilises? Dis moi comment tu fais :)
                        • Partager sur Facebook
                        • Partager sur Twitter
                          24 février 2009 à 23:09:23

                          Je l'ai utilisé une fois et il y a bien longtemps, au boulot.
                          De mémoire (me semble t il car ça fait bien longtemps) il faut remplir une structure (fournie dans les headers de la zlib) et appeler des fonctions inflate ou deflate.

                          A l'occasion, je regarderai de nouveau
                          • Partager sur Facebook
                          • Partager sur Twitter

                          Recueil de code C et C++  http://fvirtman.free.fr/recueil/index.html

                            10 mars 2009 à 22:52:47

                            Les méthodes que j'utilise traitent sur les buffers, et les compressent et décompressent.

                            Pour vraiment lire le fichier ZIP, il faut parser le fichier. Un fichier zip est fait d'une entete (qu'il faut lire), de plusieurs blocs (qui sont les fichiers, ou des parties des fichiers), ces blocs sont donc compressés comme dit plus haut, et le fichier est fini par une table qui associe les blocs aux noms de fichiers.

                            Tout cela est détaillé sur WOTSIT.org

                            Mais c'est complexe.

                            Si ton probleme est vraiment de lire ou de faire un fichier ZIP, ce sera long a faire.
                            Si ton probleme est uniquement le stockage de plusieurs fichiers dans un seul, tu peux te faire des "algos maison" pas trop complexes :)
                            • Partager sur Facebook
                            • Partager sur Twitter

                            Recueil de code C et C++  http://fvirtman.free.fr/recueil/index.html

                              12 mars 2009 à 12:32:46

                              Je ne veux pas forcément tout coder moi même, le but du programme n'étant pas de faire un dézipeur.

                              Si une bibliothèque le fait très bien et simplement, je prends!
                              • Partager sur Facebook
                              • Partager sur Twitter
                                12 mars 2009 à 18:03:31

                                Je n'pense pas qu'il existe une bibliothèque capable de "dézipper" directement une archive ".zip".

                                Comme la suggérer Fvirtman, si tu veux pouvoir décompresser une archive zip il faut t'intéresser à la structure d'un tel format de fichier ( Ce qui risque de te prendre de très longues heures de recherche ).

                                En revanche tu peux créer toi même ton propre format de fichier. A l'aide de la Zlib tu peux compresser des données venant de plusieurs fichiers pour au final "tout mettre" dans un seul fichier. Cependant il faudra que tu gardes un espace dans ton fichier réservé à différentes informations venant du processus de compression ( comme les noms des différents fichiers compréssés par exemple ). En clair c'est tout un petit système à concevoir.
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  12 mars 2009 à 18:26:28

                                  Il existe surement des gens qui ont fait ça : surcouche de Zlib. par contre, ils ne l'ont pas forcément publié sur le net.

                                  Moi ce que j'ai utilisé, c'est le inflate ou le deflate sur certains blocs zippés dans des fichiers que je gere au boulot. Pas des fichiers zip : mais des fichiers dans lesquels certains blocs sont zippés.

                                  Si tu trouves une lib qui travaille sur les fichiers ZIP, de haut niveau et simple, je suis preneur aussi :)
                                  Sinon, tu peux contourner ton probleme : tu peux te faire toi meme ton propre format, assez simplement.
                                  • Partager sur Facebook
                                  • Partager sur Twitter

                                  Recueil de code C et C++  http://fvirtman.free.fr/recueil/index.html

                                    12 mars 2009 à 19:45:41

                                    Cette question m'a beaucoup turlupiné un temps.
                                    J'ai trouvé une solution, le seul hic est qu'elle n'est pas portable.

                                    http://www.mediafire.com/download.php?knlnfgky22d

                                    Le code de la couche d'abstraction est du C++, qu'importe, les sources dans le dossier impl sont en C.
                                    C'est en fait une version modifié de la zlib que j'utilise. Elle propose une interface relativement simple.
                                    Quelques mots pour les ceux qui sont intéressés par mon warper :

                                    Je tire ce code directement de mon projet, donc ne pas prendre gare à certaines inclusions et aux namespaces.
                                    La librairie utilisée ne permet pas de modifier un fichier zip puis de le sauvegarder : il faut en créer un nouveau.
                                    De plus j'effectue un accès concurrent à ces fichier avec un autre gestionnaire (Ogre) dans mon application.
                                    Donc lorsque je les enregistres, un nouveau fichier, avec le suffixe ".new" est généré; ce n'est au'au prochain chargement du fichier (sans le .new" qu'un éventuel fichier ".new" sera substitué à l'original.

                                    Ensuite, pour enregistrer le fichier, il faut écrire quelque chose de la sorte : monZip << "make";

                                    Bref, je m'arrête là car je ne suis pas vraiment sur le bon topic.

                                    J'espère que ce code t'aidera Gni. ;)
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      14 mars 2009 à 15:35:21

                                      Je vais lire ce code. Merci ;)

                                      A Fvirtman, le problème d'un zip fait maison, c'est que le zip est crée par du php et lu par du C. Donc si je fais une mixture maison, je ne peux plus jouir du confort proposé par ma lib php pour générer les zip =_='
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        14 mars 2009 à 17:41:31

                                        Salut,

                                        Il y a quelques temps, je suis tombé sur ce lien.

                                        L'article traite des SDL_RWops, mais l'auteur explique également comment se servir d'archive zip, à l'aide de la bibliothèque zzip .

                                        a++
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        Zeste de Savoir, le site qui en a dans le citron !
                                          15 mars 2009 à 12:53:46

                                          libzip (dépend de zlib)
                                          man pages

                                          score.txt dans archive.zip:
                                          A: _65_
                                          B: _70_
                                          C: _90_
                                          D: _542_
                                          E: _23_
                                          Z: _98_
                                          I: _265_
                                          I: _450_


                                          exemple(pas très bien fait avec les exit()):

                                          #include <stdio.h>
                                          #include <stdlib.h>
                                          #include <string.h>
                                          #include <errno.h>
                                          #include <assert.h>
                                          
                                          #include <zip.h>
                                          
                                          int main(void)
                                          {
                                              const char path[]="archive.zip";
                                              char buf[256];
                                          
                                              int err=0,i,s,score;
                                              struct zip *archive;
                                              struct zip_file *fpz=NULL;
                                              struct zip_stat sb;
                                              char *p,*p2,car;
                                              archive=zip_open(path,ZIP_CHECKCONS,&err);
                                              if(err != 0 || !archive)
                                              {
                                                  zip_error_to_str(buf, sizeof buf, err, errno);
                                                  fprintf(stderr,"«%s» %d in function «%s» ,err=%d\n«%s»\n",__FILE__,__LINE__,__FUNCTION__,err,buf);
                                                  exit(EXIT_FAILURE);
                                              }
                                          
                                              /*pour lire un fichier spécifique (sinon voir 'zip_fopen_index')*/
                                              fpz=zip_fopen(archive,"score.txt",ZIP_FL_UNCHANGED);
                                              if(!fpz)
                                              {
                                                  strcpy(buf,zip_strerror(archive));
                                                  fprintf(stderr,"«%s» %d in function «%s»\n«%s»\n",__FILE__,__LINE__,__FUNCTION__,buf);
                                                  zip_close(archive);
                                                  exit(EXIT_FAILURE);
                                              }
                                          
                                              /*pour savoir la taille du fichier et ainsi pouvoir le lire en entier*/
                                              if(zip_stat(archive, "score.txt", 0, &sb) == -1)
                                              {
                                                  strcpy(buf,zip_strerror(archive));
                                                  fprintf(stderr,"«%s» %d in function «%s»\n«%s»\n",__FILE__,__LINE__,__FUNCTION__,buf);
                                                  zip_fclose(fpz);
                                                  zip_close(archive);
                                                  exit(EXIT_FAILURE);
                                              }
                                          
                                              p=malloc(sb.size*sizeof(char)+1);
                                              assert(p != NULL);
                                              /*lit le fichier*/
                                              if(zip_fread(fpz,p,sb.size) != sb.size)
                                              {
                                                  fprintf(stderr,"«%s» %d in function «%s»\n«read error ...»\n",__FILE__,__LINE__,__FUNCTION__);
                                                  free(p);
                                                  zip_fclose(fpz);
                                                  zip_close(archive);
                                                  exit(EXIT_FAILURE);
                                              }
                                          
                                              /*plus besoin tout est dans p*/
                                              zip_fclose(fpz);
                                              zip_close(archive);
                                          
                                              /*affiche le contenu brute*/
                                              puts(p);
                                          
                                              /*pour la mise en forme des données (partie mal faite)*/
                                          
                                              s=0;
                                              i=0;
                                              /* s = nombre de ligne */
                                              while(p[i])
                                              {
                                                  if(p[i] == '\n' && p[i] != 0)
                                                  s++;
                                                  i++;
                                              }
                                              i=0;
                                              /* p2 = ligne actuelle*/
                                              p2=p;
                                              while(s)
                                              {
                                                  /*on lit une ligne de score*/
                                                  sscanf(p2,"%c: _%d_\n",&car,&score);
                                          
                                                  /*on affiche les données*/
                                                  printf("Le joueur %c a %d points.\n",car,score);
                                          
                                                  /*on va à la ligne suivante*/
                                                  while(p2[i] != '\n')i++;
                                                  p2+=(i+1);
                                                  i=0;
                                          
                                                  s--;
                                              }
                                          
                                              free(p);
                                              return 0;
                                          }
                                          


                                          en sortie:
                                          $ time ./bin/Debug/0 
                                          A: _65_
                                          B: _70_
                                          C: _90_
                                          D: _542_
                                          E: _23_
                                          Z: _98_
                                          I: _265_
                                          I: _450_
                                          
                                          Le joueur A a 65 points.
                                          Le joueur B a 70 points.
                                          Le joueur C a 90 points.
                                          Le joueur D a 542 points.
                                          Le joueur E a 23 points.
                                          Le joueur Z a 98 points.
                                          Le joueur I a 265 points.
                                          Le joueur I a 450 points.
                                          
                                          real        0m0.003s
                                          user        0m0.000s
                                          sys        0m0.004s
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            15 mars 2009 à 13:56:32

                                            Hum, intéressant, cette lib est utilisé par de gros projets open source, pourtant je l'ai loupée dans ma prospection.

                                            Ca m'intéresse car celle-ci est portable. :)
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              15 mars 2009 à 16:07:44

                                              Je crois que c'est exactement ce qu'il me faut.
                                              !
                                              J'essaye ça et je vous tiens au courant :)

                                              Merci :soleil: !
                                              • Partager sur Facebook
                                              • Partager sur Twitter

                                              [C] Zip et Unzip

                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                              • Editeur
                                              • Markdown