glenux-school/m2.enlarge-your-data
glenux-school/m2.enlarge-your-data
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Browse source
This commit is contained in:
glenux 2005-10-30 23:00:42 +00:00
parent 677add88f0
commit c92bb5e352
4 changed files with 162 additions and 234 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

114
src/tools/eydrle.cpp
View file

@ -1,102 +1,20 @@
#include "eyd.hh" #include "eydrle.hh"
using namespace std; namespace EydTools {
EydRle::EydRle(){
_mode_compress = EYDRLE_MODE_UNDEF;
_input_file.clear();
int main(int argc, char **argv){ _output_file.clear();
/* _cellsize = 8; // one octet each time (by default);
std::string *servermsgold, *usermsg, *userparam; }
int ret;
char * tmp_c_string; void EydRle::run(){
ftp_cmd_t ftp_cmd; if (_mode_compress == EYDRLE_MODE_COMPRESS){
this->compress();
ftp_connection_state_t cnx_state; } else {
FtpConfig * client_conf = NULL; this->uncompress();
}
servermsgold = NULL;
usermsg = NULL;
userparam = NULL;
cnx_state = FTP_STATE_DISCONNECTED;
client_conf = new FtpConfig();
ret = miniftp_args(client_conf, argc, argv);
if (ret < 0) { return EXIT_FAILURE; }
printf("Connecting to %s:%d\n... ",
client_conf->server_conf->host->c_str(),
client_conf->server_conf->port);
fflush(stdout);
XionFS::XSock *cmdXSock; // *dataXSock;
cmdXSock = new XionFS::XSock(XionFS::CLIENT,XionFS::TCP);
cmdXSock->port(client_conf->server_conf->port);
cmdXSock->dns(client_conf->server_conf->host->c_str());
cmdXSock->launch();
printf(" fait\n");
client_conf->cmd_xsocket = cmdXSock;
// init sequence
MiniFtp::ServerMsg * servermsg;
// ("220 hophop");
servermsg = ftp_cmd_recv(client_conf);
if ((servermsg->getStatus()/10) == 22){
cnx_state = FTP_STATE_CONNECTED;
} else {
cout << "ERROR\n";
return EXIT_FAILURE; // event system
}
delete(servermsg);
// init
cout <<"Auth...\n";
while(cnx_state == FTP_STATE_CONNECTED){
tmp_c_string = readline("Login...: ");
usermsg = new std::string(tmp_c_string);
ftp_cmd_send(client_conf, FTP_CMD_USER, (char*)usermsg->c_str());
free(tmp_c_string);
delete(usermsg);
servermsg = ftp_cmd_recv(client_conf);
if (servermsg->getStatus() != 331){
continue;
}
delete(servermsg);
tmp_c_string = readline("Password: ");
usermsg = new std::string(tmp_c_string);
ftp_cmd_send(client_conf, FTP_CMD_PASS, (char*)usermsg->c_str());
delete(usermsg);
servermsg = ftp_cmd_recv(client_conf);
if ((servermsg->getStatus() / 10) == 23){
cnx_state = FTP_STATE_LOGGED_IN;
}
delete(usermsg);
}
while(cnx_state == FTP_STATE_LOGGED_IN){
tmp_c_string = readline("ftp> ");
usermsg = new std::string(tmp_c_string);
//userparam = (char *) malloc(sizeof(char) * CLIENTQUERY_MAX_LENGTH);
ftp_cmd = ftp_cmd_parse(usermsg, &userparam);
//Think to keep FTP filesystem tree somewhere
ftp_cmd_send(client_conf, ftp_cmd, userparam);
if (ftp_cmd == FTP_CMD_QUIT){
printf("Disconnecting...\n");
cnx_state = FTP_STATE_DISCONNECTED;
}
free(userparam);
delete(usermsg);
free(tmp_c_string);
} }
// on le garde dans un coin au chaud en attendant
// dataXSock->launch();
*/
return 0;
} }

93
src/tools/eydrle_compress.cpp
View file

@ -1,45 +1,41 @@
#include <stdio.h> #include "eydrle.hh"
#include <stdlib.h>
#include <eyd.hh>
#include <exception>
#include <vector>
void usage(){ namespace EydTools {
printf("usage : bitcopy <int> <file>\n"); void EydRle::compress(){
} EydLib::BitGroup data;
int main(int argc, char ** argv){ EydLib::BitReader bitread(_cellsize, 256);
EydLib::BitGroup data; bitread.open(_input_file);
int cell_size;
std::string original;
std::string copy;
if (argc<2){ usage(); exit(-1); } EydLib::BitWriter bitwrite(_cellsize,256);
cell_size = atoi(argv[1]); bitwrite.open(_output_file);
original = argv[2]; unsigned char c = (unsigned char)_cellsize;
bitwrite.writeDirect(&c, 1);
copy = original + ".rl1"; EydLib::BitCompressor compressor(_cellsize);
EydLib::BitReader bitread(cell_size, 256); printf("File opened\n");
bitread.open(original);
EydLib::BitWriter bitwrite(cell_size,256); bool done=false;
bitwrite.open(copy); std::vector<EydLib::BitGroup> record;
unsigned char c = (unsigned char)cell_size; while(!done){
bitwrite.writeDirect(&c, 1); try{
data = bitread.read();
compressor.append(data);
EydLib::BitCompressor compressor(cell_size); if (compressor.hasContent()){
std::list<EydLib::BitGroup> compressedData = compressor.flush();
printf("File opened\n"); std::list<EydLib::BitGroup>::iterator cmpDataIt;
for(cmpDataIt = compressedData.begin();
bool done=false; cmpDataIt != compressedData.end();
std::vector<EydLib::BitGroup> record; cmpDataIt++){
while(!done){ bitwrite.write((*cmpDataIt)); // cellule
try{ }
data = bitread.read(); }
compressor.append(data); } catch (EydLib::eBitReaderEndOfFile& e) {
done = true;
if (compressor.hasContent()){ // on flushe le contenu de record
compressor.flushRleData();
std::list<EydLib::BitGroup> compressedData = compressor.flush(); std::list<EydLib::BitGroup> compressedData = compressor.flush();
std::list<EydLib::BitGroup>::iterator cmpDataIt; std::list<EydLib::BitGroup>::iterator cmpDataIt;
for(cmpDataIt = compressedData.begin(); for(cmpDataIt = compressedData.begin();
@ -47,26 +43,15 @@ int main(int argc, char ** argv){
cmpDataIt++){ cmpDataIt++){
bitwrite.write((*cmpDataIt)); // cellule bitwrite.write((*cmpDataIt)); // cellule
} }
} catch (std::exception& e){
printf("ERROR\n");
} }
} catch (EydLib::eBitReaderEndOfFile& e) {
done = true;
// TODO: on flushe le contenu de record
compressor.flushRleData();
std::list<EydLib::BitGroup> compressedData = compressor.flush();
std::list<EydLib::BitGroup>::iterator cmpDataIt;
for(cmpDataIt = compressedData.begin();
cmpDataIt != compressedData.end();
cmpDataIt++){
bitwrite.write((*cmpDataIt)); // cellule
}
} catch (std::exception& e){
printf("ERROR\n");
} }
printf("compression done\n");
bitread.close();
bitwrite.close();
printf("file closed\n");
} }
printf("compression done\n");
bitread.close();
bitwrite.close();
printf("file closed\n");
} }

91
src/tools/eydrle_init.cpp
View file

@ -1,34 +1,71 @@
#include "eyd.hh" #include "eydrle.hh"
/* namespace EydTools {
int miniftp_args(MiniFtp::FtpConfig * client_conf, int argc, char ** argv){ // GOOD
int i;
for (i = 1; i + 1 < argc; i = i + 2){ bool EydRle::init(int argc, char ** argv){
char * opt = argv[i]; //GOOD _mode_compress = EYDRLE_MODE_UNDEF;
char * val = argv[i+1]; //GOOD
if ( (strcmp(opt, "--port") == 0) || (strcmp(opt,"-p") == 0) ){ int i;
client_conf->setServerPort(atoi(val)); for (i = 1; i + 1 < argc; i = i + 2){
continue; char * opt = argv[i]; //GOOD
} char * val = argv[i+1]; //GOOD
if ( (strcmp(opt, "--host") == 0) || (strcmp(opt,"-h") == 0) ){ if ( (strcmp(opt, "--mode") == 0) || (strcmp(opt,"-m") == 0) ){
client_conf->setServerHost(std::string(val)); switch(val[0]){
continue; case 'c':
case 'C':
_mode_compress = EYDRLE_MODE_COMPRESS;
break;
case 'u':
case 'U':
_mode_compress = EYDRLE_MODE_UNCOMPRESS;
break;
default:
_mode_compress = EYDRLE_MODE_UNDEF;
break;
}
continue;
}
if ( (strcmp(opt, "--input") == 0) || (strcmp(opt,"-i") == 0) ){
_input_file = val;
}
if ( (strcmp(opt, "--output") == 0) || (strcmp(opt,"-o") == 0) ){
_output_file = val;
}
if ( (strcmp(opt, "--cellsize") == 0) || (strcmp(opt,"-c") == 0) ){
_cellsize = atoi(val);
}
// printf("Option = %s, ",argv[i]);
// printf("value = %s\n",argv[i+1]);
} }
// printf("Option = %s, ",argv[i]); if ((_mode_compress == EYDRLE_MODE_UNDEF) ||
// printf("value = %s\n",argv[i+1]); (_input_file.length() == 0)) {
printf("\nUsage: %s <options>\n", argv[0]);
printf("\nWhere options could be:\n");
printf("-m, --mode (c|u) Compress or uncompress\n");
printf("-i, --input <file> File to compress | uncompress\n");
printf("-o, --output <file> Destination file\n");
printf("-c, --cellsize <file> Cell size (in bits)\n");
return false;
}
if (_output_file.length() == 0){
if (_mode_compress == EYDRLE_MODE_COMPRESS){
_output_file = _input_file + ".rl1";
} else {
_output_file = _input_file + ".rl1_orig";
}
}
// setting rle
EydLib::BitGroup rleFinal(_cellsize);
_rle = rleFinal;
return true;
} }
if (!client_conf->hasServerHost()
|| !client_conf->hasServerPort()) {
printf("\nUsage: %s <options>\n", argv[0]);
printf("\nWhere options could be:\n");
printf("-p, --port <integer> Port to connect on host\n");
printf("-h, --host <string> DNS or IP address of the FTP host\n");
return -1;
}
return 1;
} }
*/

98
src/tools/eydrle_uncompress.cpp
View file

@ -1,47 +1,47 @@
#include <stdio.h> #include "eydrle.hh"
#include <stdlib.h>
#include <eyd.hh>
#include <exception>
#include <vector>
void usage(){ namespace EydTools {
printf("usage : bitcopy <int> <file>\n"); void EydRle::uncompress(){
} EydLib::BitGroup data;
int main(int argc, char ** argv){ EydLib::BitReader bitread(_cellsize, 256);
EydLib::BitGroup data; bitread.open(_input_file);
int cell_size;
std::string original;
std::string copy;
if (argc<2){ usage(); exit(-1); } unsigned char c;
cell_size = atoi(argv[1]); bitread.readDirect(&c, 1);
original = argv[2]; //TODO: fixer cell_size en fonction de "c";
copy = original + ".rl2"; if (c != _cellsize){
printf("WARNING : File cellsize is %d, but uncompressing with %d\n",c, _cellsize);
}
EydLib::BitReader bitread(cell_size, 256); EydLib::BitWriter bitwrite(_cellsize,256);
bitread.open(original); bitwrite.open(_output_file);
unsigned char c; EydLib::BitUncompressor uncompressor(_cellsize);
bitread.readDirect(&c, 1);
//TODO: fixer cell_size en fonction de "c";
EydLib::BitWriter bitwrite(cell_size,256); printf("File opened\n");
bitwrite.open(copy);
EydLib::BitUncompressor uncompressor(cell_size); bool done=false;
std::vector<EydLib::BitGroup> record;
while(!done){
try{
data = bitread.read();
uncompressor.append(data);
printf("File opened\n"); if (uncompressor.hasContent()){
std::list<EydLib::BitGroup> uncompressedData = uncompressor.flush();
bool done=false; std::list<EydLib::BitGroup>::iterator uncmpDataIt;
std::vector<EydLib::BitGroup> record; for(uncmpDataIt = uncompressedData.begin();
while(!done){ uncmpDataIt != uncompressedData.end();
try{ uncmpDataIt++){
data = bitread.read(); bitwrite.write((*uncmpDataIt)); // cellule
uncompressor.append(data); }
}
if (uncompressor.hasContent()){ } catch (EydLib::eBitReaderEndOfFile& e) {
done = true;
// on flushe le contenu de record
// uncompressor.flushRleData();
std::list<EydLib::BitGroup> uncompressedData = uncompressor.flush(); std::list<EydLib::BitGroup> uncompressedData = uncompressor.flush();
std::list<EydLib::BitGroup>::iterator uncmpDataIt; std::list<EydLib::BitGroup>::iterator uncmpDataIt;
for(uncmpDataIt = uncompressedData.begin(); for(uncmpDataIt = uncompressedData.begin();
@ -49,27 +49,15 @@ int main(int argc, char ** argv){
uncmpDataIt++){ uncmpDataIt++){
bitwrite.write((*uncmpDataIt)); // cellule bitwrite.write((*uncmpDataIt)); // cellule
} }
} catch (std::exception& e){
printf("ERROR\n");
} }
} catch (EydLib::eBitReaderEndOfFile& e) {
done = true;
// on flushe le contenu de record
// FIXME: trouver un moyen de flusher la fin du fichier
// uncompressor.flushRleData();
std::list<EydLib::BitGroup> uncompressedData = uncompressor.flush();
std::list<EydLib::BitGroup>::iterator uncmpDataIt;
for(uncmpDataIt = uncompressedData.begin();
uncmpDataIt != uncompressedData.end();
uncmpDataIt++){
bitwrite.write((*uncmpDataIt)); // cellule
}
} catch (std::exception& e){
printf("ERROR\n");
} }
printf("uncompression done\n");
bitread.close();
bitwrite.close();
printf("file closed\n");
} }
printf("uncompression done\n");
bitread.close();
bitwrite.close();
printf("file closed\n");
} }