8__PAGEZERO__TEXT __text__TEXTD D__picsymbol_stub__TEXT+$__symbol_stub__TEXT+__picsymbolstub1__TEXT+@ __cstring__TEXT.DD__DATA0 __data__DATA0 __la_symbol_ptr__DATA0 h __nl_symbol_ptr__DATA0 4__dyld__DATA0 __common__DATA0<8__LINKEDIT@0 /usr/lib/dyld 4Cd'G/usr/lib/libSystem.B.dylib003L P282@(D|: x8!T!48!z8;cW{:|=`ak}iN |!B||x|#x|+xH<_h<_l<_p<_B/A }N!<_B/A }N!H I<_| /A }N!H<_x /A }N!<8c8@Hea@/AH 8<_B=}"Kx/Ad9@9` |t/A0|X|t//@}K9k}"Kx| X|t/@/A 8 H<_tx/A/@xxx8HH |B}=|9 }N |B}=|9}N |B}=|9 }N |B}=|94}N |B}=|9X}N |B}=|9 }N |B}=|9}N |!B<8c \8@H@}N!h8!`|N |B}=|9l}N =`k0,AN 8N8`.8`8D8`;8D= 0| =aN =`k0}iN |!|> x~x|8`8(H e|`x@^@x^@|^@8(@8`-H }8`-@H ݀!|N |B}=|9 }N |B}=|9 }N |B}=|9 }N |!|> x~x|8H8`-H ]~@8@D^D/@Hx^DBBx@L^DBB|@4^DH>D^H ^H/(AH^DB8DK|8`-@HH/A4^H /A^H ~H| x}N!~HH!!|N |B}=|9}N |B}=|9 }N |B}=|9}N |B}=|9}N |!|> xBHM<_B @@@/A^@T>+@H<_b H<_b H!|N |B}=|9}N |B}=|9}N |B}=|9}N |BА|~x!|#x8`:Hဝ<8c H}88H8/||xA/@xxH|`xHx8:@88H!88~xH8 ~xxH<8c H1<~x8 H/A<8c H H888xH<8c H%88x8Hx8@8HA@/@<8c HH888xHQ@<8c Ha@Tc8H|yy@<8c (HHLA@;y;W8|x888xHx8xH88x8H|.;x|8|x|pH;@@;:@:x:sAz~xH/zA0|dxxH~óxHzH=HT|.;`@D/|x@;8@xx{H~óx8@xH5|.A~óxHHt88~xH~xxH}<~x8c @H~x8 8H/|vxA/@ ~xH8cH~x|txHMx888HY@;:;ZA/Ap~xH18cH|~yA4<_~x8B T">HxHxH~xHH<~x8c \H8H#xH8|x8!|N |B!T<|}x<8B|#x8cx|+xAHHx8 8Hu/||x@<x8cPHy8`H\x8@8H/a@@|ex8@xHEK;`@;W}:|}.H|.|`x|exx@H 88@xH|.<8cH|}.88DH/|~x@(|.<8cHx8D8HHXx8@8H/a@@$|ex8@xH}D|DKx8D8H]xH5;{A8H8xH9<88 xH%xH8`x8!p|N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|l}N |B}h=k|P}N |B}h=k|4}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|p}N |B}h=k|T}N |B}h=k|8}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|}N |B}h=k|t}N |B}h=k|X}N __dyld_mod_term_funcs__dyld_make_delayed_module_initializer_callsThe kernel support for the dynamic linker is not present to run this program. ESTVALIDEJ'ouvre %s Check %s Pack %s vide Suffixe OKPack videTrouv %lu zones de donnes Mmoire insuffisanteExtraction de %s open Impossible de crer %s, le fichier existe surement dj Cration du pack %s Ajout de %s Attention, erreur sur %s .D0$<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!0 00 4 0K 0h 0 0 0 0 0 0  0. 0P 0t 00 0CQw$,4<C_` 'nTT     ( )  -)+,/#'*($!%&. -)+,/#'*($!%&."_NXArgc_NXArgv___progname__mh_execute_header_catch_exception_raise_catch_exception_raise_state_catch_exception_raise_state_identity_clock_alarm_reply_do_mach_notify_dead_name_do_mach_notify_no_senders_do_mach_notify_port_deleted_do_mach_notify_send_once_do_seqnos_mach_notify_dead_name_do_seqnos_mach_notify_no_senders_do_seqnos_mach_notify_port_deleted_do_seqnos_mach_notify_send_once_environ_receive_samples___keymgr_dwarf2_register_sections___keymgr_global__cthread_init_routine__dyld_register_func_for_add_image__dyld_register_func_for_remove_image__init_keymgr__keymgr_get_and_lock_processwide_ptr__keymgr_set_and_unlock_processwide_ptr_abort_atexit_calloc_close_errno_exit_free_lseek_mach_init_routine_malloc_memset_open_printf_puts_read_strcat_strcmp_strcpy_strlen_system_umask_writebuildpacker.command#!/bin/bash cd `dirname $0` gcc -DMACOSX -O2 -o Packer_OSX Packer.c && strip Packer_OSX && clear && echo "Packer_OSX OK" yPacker.c// Packer.c - Ecrit par Xavier Garreau // Licence NOL - http://wfr.tcl.tk/nol // // Compilation: // - OSX : // gcc -DMACOSX -O2 -o zpacker Packer.c && strip zpacker // - Windows : // Compiler comme application console // fichiers VC++ en ligne : http://fichiers.xgarreau.org/zazoupacker/ // // CHANGELOG: // Cr le 04 fv. 2006 // Modifi le 10 fv. 2006: // - Support OSX // - Quelques const ajouts deci dela // Modifi le 12 fv. 2006: // - appel umask supprim sous windows #include #include #include #include #ifdef WIN32 #include #include #else #include #include #include #include #define O_BINARY 0 #define _MAX_PATH PATH_MAX #define open(x, y) open((x), (y), S_IRWXU | S_IRWXG | S_IRWXO) #endif // La fonction qui cre un pack // Le main se charge quand lui du fonctionnement normal int fait_pack (int fd, int argc, char** argv); const char CHECK_SUFFIX[] = "ESTVALIDE"; typedef struct _datatype { long size; // Limit 2G par bloc de donnes sur la plupart des architectures void* content; } datatype; /* La structure packe est la suivante - EXE - donnes taille_des_donnes - donnes taille_des_donnes - ... - nb de couples (donnes taille_des_donnes) - ESTVALIDE le nombre de couples tant stock comme long */ int main(int argc, char** argv) { int fd, datafd; long nb_couples, i; datatype* data; char buffer[_MAX_PATH]; char* commandarg = NULL; const long suffix_len = sizeof(CHECK_SUFFIX); const long l_size = sizeof(long); // je considre que les read fonctionnent toujours, a claircit le code mais c'est mal // il faut toujours vrifier que read a bien renvoy le nombre d'octets qu'on lui a demand // de lire, sinon, on n'a pas lu tout ce qu'on s'attendait lire. // Dans le cas de ce programme ce n'est pas trs grave car on ne risque pas de tomber sur une // fin de fichier mais dans le cas de la prog rseau a devient vite trs grave. // Il faudrait galement vrifier que les lseek ne remontent pas trop haut et ne // retournent pas -1 (erreur) // on pourrait enfin sparer les donnes par un caractre particulier pour s'assurer qu'on // se trouve bien sur une "frontire" quand on est cens y tre #ifndef WIN32 umask (S_IWOTH | S_IWGRP); #endif printf ("J'ouvre %s\n", argv[0]); fd = open (argv[0], O_RDONLY | O_BINARY); if (-1 == fd) { return 1; } // On s'est auto ouvert. Cool :) if (argc>1) { return fait_pack (fd, argc, argv); } lseek (fd, -suffix_len, SEEK_END); memset (buffer, 0, sizeof(buffer)); read (fd, buffer, suffix_len); printf ("Check %s\n", argv[0]); if (0 != strcmp(buffer, CHECK_SUFFIX)) { // On n'a pas le suffixe, il n'y a donc pas de pack // On rend la main // il faudrait fermer fd par un close (fd) mais // en pratique, c'est fait par le systme ... printf ("Pack %s vide\n", argv[0]); return 0; } lseek (fd, -suffix_len, SEEK_CUR); // Si on arrive l, on a le suffixe en fin de fichier. printf ("Suffixe OK\n", argv[0]); // On peut rcuprer le nombre de donnes packes // On part du principe qu'un long est toujours cod sur le mme nombre d'octets // a peut tre faux, rarement, mais a peut. (La pluspart du temps, un long est cod // sur 4 octets lseek (fd, -l_size, SEEK_CUR); read (fd, &nb_couples, l_size); if (0 == nb_couples) { // S'il n'y a pas de donnes, rien faire printf ("Pack vide\n"); return 0; } lseek (fd, -l_size, SEEK_CUR); printf ("Trouv %lu zones de donnes\n", nb_couples); // On alloue de la mmoire pour stocker nos donnes data = (datatype*)malloc(nb_couples * sizeof(datatype)); if (!data) { printf ("Mmoire insuffisante\n"); return 1; } // Ici, tout dpend de ce qu'on veut faire de nos donnes // On peut les charger en mmoire, si ce sont des ressources // on peut en crer des fichiers comme dans le cas d'un zip ... // je vais prendre le cas d'un "packageur de pages web" pour l'exemple // Je vais partir du principe que les donnes ranges dans le pack sont // le nom d'un fichier et son contenu, le nom d'un fichier et son contenu, ... // donc, je sors les fichiers du pack et je lance la visualisation // des fichiers ainsi extraits du pack. // Je dcide aussi arbitrairement, que le premier fichier sorti est la "page d'accueil" // On peut amliorer le fonctionnement, en stockant des chemins relatifs, pour reconstruire // une arborescence. // On peut galement compresser le tout, mais on n'est pas l pour rcrire winrar ou 7zip ;) // On commence par rcuprer les tailles de nos "morceaux" i = nb_couples-1; do { lseek (fd, -l_size, SEEK_CUR); read (fd, &(data[i].size), l_size); lseek (fd, -l_size, SEEK_CUR); // On saute les donnes, on y reviendra plus tard lseek (fd, -data[i].size, SEEK_CUR); } while (i--); // L on se trouve en tte des donnes dans l'exe // Avec notre tableau de tailles prrempli // on va lire les donnes en incrmentant i de 0 nb_couples-1 // comme on a un nom et un contenu // quand i est pair, c'est un nom donc on ouvre un fichier. // quand i est impair on envoie les donnes dans le descripteur. datafd = -1; // on ne fait prequ'aucun contrle d'erreur, c'est trs trs mal ! for (i=0; i data[i].size ? 1024 : data[i].size; read (fd, buffer, octets_a_lire); write (datafd, buffer, octets_a_lire); octets_ok += octets_a_lire; } } close (datafd); } else { //i pair memset (buffer, 0, sizeof(buffer)); read (fd, buffer, data[i].size); printf ("Extraction de %s\n", buffer); datafd = open (buffer, O_WRONLY | O_CREAT | O_EXCL | O_BINARY); if (-1 == datafd) { printf ("Impossible de crer %s, le fichier existe surement dj\n", buffer); return 1; } if (0==i) { commandarg = (char*) malloc (strlen(buffer)+1); strcpy (commandarg, buffer); } } // On passe sur la taille, on la connait dj lseek (fd, l_size, SEEK_CUR); } if (commandarg) { #ifdef WIN32 ShellExecute(NULL, NULL, commandarg, NULL, NULL, SW_SHOWNORMAL); #elif defined MACOSX char* command = (char*) malloc (5+strlen(commandarg)+1); if (command) { strcpy (command, "open "); strcat (command, commandarg); system (command); free (command); } #endif free (commandarg); } // Pas ncessaire ici mais si on faisait autre chose // Il ne faudrait pas oublier de le faire free (data); return 0; } // La fonction qui fait le pack int fait_pack (int fd, int argc, char** argv) { int param; int packfd, datafd; char buffer[4096]; long bufferlen; long taille; long nb_couples = (argc-2)*2; char* pack = argv[1]; const long l_size = sizeof(long); const long suffix_len = sizeof(CHECK_SUFFIX); printf ("Cration du pack %s\n", pack); packfd = open (pack, O_WRONLY | O_CREAT | O_EXCL | O_BINARY); if (-1 == packfd) { printf ("Impossible de crer %s, le fichier existe surement dj\n", pack); return 1; } // on commence par copier l'excutable dans ce pack do { bufferlen = read (fd, buffer, sizeof(buffer)); if (bufferlen > 0) write (packfd, buffer, bufferlen); else break; } while (1); // Ensuite, on ajoute les fichiers passs en ligne de commande // Cette zone l aussi devrat comprendre beaucoup plus de contrles d'erreurs // On devrait galement comparer le nombre d'octets lus avec la taille du fichier param = 1; while (++param < argc) { // une donne pour le nom bufferlen=strlen(argv[param]); write (packfd, argv[param], bufferlen); write (packfd, &bufferlen, l_size); printf ("Ajout de %s\n", argv[param]); // une donne pour le contenu taille = 0; datafd = open (argv[param], O_RDONLY | O_BINARY); if (-1 == datafd) { printf ("Attention, erreur sur %s\n", argv[param]); write (packfd, &taille, l_size); continue; } do { bufferlen = read (datafd, buffer, sizeof(buffer)); if (bufferlen > 0) taille += write (packfd, buffer, bufferlen); else break; } while (1); write (packfd, &taille, l_size); close (datafd); } // on ajoute le nombre de donnes write (packfd, &nb_couples, l_size); // on ajoute le suffixe write (packfd, CHECK_SUFFIX, suffix_len); close (packfd); return 0; } #ESTVALIDE