int main(int argc, char** argv) {
long id = 0;
char *nombre;
if (argc >= 3) {
id = getLong(argv[1]);
nombre = getString(argv[2]);
fprintf(stdout, "\nGenerando Archivo %s con id %ld", nombre, id);
comprimir(id, nombre);
return EXIT_SUCCESS;
} else {
fprintf(stdout, "\nForma de uso: %s id nombre_archivo", argv[0]);
return EXIT_FAILURE;
}
}
int main(int argc, char *argv[])
{
FILE *fpin, *fpout;
struct nodo *raiz;
struct tablaCod *tabla;
struct header h;
u16 v;
int verbose=0, benchmark=0;
double tiempo;
printf("hufc v. 0.2.2 Compress/Expand files using Huffman coding\n");
if (argc < 2)
{
printf("To see help, write: %s -h\n", argv[0]);
exit(0);
}
// Mostrar la ayuda?
if (ExistArg("-h", argc, argv))
{
sintaxis(argv[0]);
exit(0);
}
// Modo verbose?
if (ExistArg("-v", argc, argv))
verbose=1;
// Medir el tiempo de crc o de checksum?
if (ExistArg("-b", argc, argv))
benchmark=1;
if ((fpin=fopen(argv[1], "rb")) == NULL)
{
perror("fopen: input file");
exit(1);
}
// Leer crc o checksum?
if (ExistArg("-r", argc, argv))
{
if (!isHuf(fpin))
printf("%s: not in huf format!\n", argv[1]);
else
{
switch (leerDetErr(fpin))
{
case USE_CCITT:
printf("%s: crc = 0x%04X\n", argv[1], readcrcsum(fpin));
break;
case USE_CHECKSUM:
printf("%s: checksum = 0x%04X\n", argv[1], readcrcsum(fpin));
break;
default:
printf("%s: error detection not used\n", argv[1]);
}
}
fclose(fpin);
exit(0);
}
// Testear el fichero?
if (ExistArg("-t", argc, argv))
{
if (!isHuf(fpin))
printf("%s: not in huf format!\n", argv[1]);
else
{
switch (testfile(fpin, leerDetErr(fpin)))
{
case FILE_OK:
printf("%s: seems to be ok\n", argv[1]);
break;
case FILE_CORRUPTED:
printf("%s: file corrupted!\n", argv[1]);
break;
default:
printf("%s: error detection not used\n", argv[1]);
}
}
fclose(fpin);
exit(0);
}
// Descomprimir
if (ExistArg("-x", argc, argv))
{
if (!isHuf(fpin))
{
printf("%s: not in huf format!\n", argv[1]);
fclose(fpin);
exit(0);
}
// Testeamos el fichero
h.deterr=leerDetErr(fpin);
if (testfile(fpin, h.deterr) == FILE_CORRUPTED)
{
printf("%s: file corrupted!\n", argv[1]);
fclose(fpin);
exit(0);
}
raiz=leerCabecera(fpin, &h);
fpout=fopen(h.filename, "wb");
if (fpout == NULL)
{
perror("fopen: output file");
exit(1);
}
// Le damos al fichero sus permisos originales
chmod(h.filename, h.permisos);
descomprimir(fpin, fpout, raiz, &h, verbose);
}
// Comprimir
else
{
if (verbose)
{
printf("Scanning file (this may take a while)... ");
fflush(stdout);
}
calcularFreq(fpin, &raiz);
if (verbose)
printf("Done\n");
raiz=crearArbolHuffman(raiz);
tabla=crearTablaCod(raiz);
if (ExistArg("-ccitt", argc, argv))
h.deterr=USE_CCITT;
else if (ExistArg("-sum", argc, argv))
h.deterr=USE_CHECKSUM;
else
h.deterr=DONT_USE_ERR_DET;
setHeaderPermisos(&h, argv[1]);
setHeaderFileName(&h, argv[1]);
fpout=fopen(getCompressedFileName(&h), "w+b");
if (fpout == NULL)
{
perror("fopen: output file");
exit(1);
}
escribirCabecera(fpout, &h, raiz);
h.padding_bits=comprimir(fpin, fpout, tabla, verbose);
escribirPadding(fpout, h.padding_bits);
borrarTablaCod(tabla);
fflush(fpout);
switch (h.deterr)
{
case USE_CCITT:
if (benchmark)
tiempo=gettime();
v=calculacrc(fpout);
if (verbose)
printf(" crc = 0x%04X\n", v);
if (benchmark)
printf("crc time: %g s\n", gettime()-tiempo);
writecrcsum(fpout, v);
break;
case USE_CHECKSUM:
if (benchmark)
tiempo=gettime();
v=calculasum(fpout, COMPRIMIR);
if (verbose)
printf(" checksum = 0x%04X\n", v);
if (benchmark)
printf("checksum time: %g s\n", gettime()-tiempo);
writecrcsum(fpout, v);
break;
default:
if (verbose)
printf("\n");
}
}
borrarArbolHuffman(raiz);
fclose(fpin);
fclose(fpout);
return 0;
}
int main(void){
char *path = "/etc/proyecto_so_1/proy1.ini";
char *line = NULL;
size_t len = 0;
ssize_t reading;
openlog("ALERT_DAEMON", LOG_PID, LOG_DAEMON);
FILE *fp;
fp = fopen(path,"r");
if (fp == NULL){
syslog(LOG_ERR,"Fallo en la lectura del archivo de conf proy1.ini");
closelog();
exit(EXIT_FAILURE);
//notificar por medio de syslog que no se encontro el proy1.ini
}else{
while(!feof(fp)){
while ((reading = getline(&line, &len, fp)) != -1) {
if(line[0] != ';'){
if(line[0] != '[' && line != NULL){
//printf("Linea %s\n",line);
char *buf;
buf = strsep(&line,"=");
if((strcmp(buf,"log_tag"))==0){
tag = strsep(&line,"\0");
}
if((strcmp(buf,"interval"))==0){
buf = strsep(&line,"\0");
interval = atoi(buf);
}
}
}
}
}
}
openlog(tag, LOG_PID, LOG_DAEMON);
if ((lista = (Lista *) malloc (sizeof (Lista))) == NULL){
syslog(LOG_ERR,"Error, no se pudo inicializar la lista");
exit(EXIT_FAILURE);
}
incializacion(lista);
while(1==1){
sleep(interval);
char *dir="/var/log";
struct dirent *dp;
DIR *fd;
char *val,**paragraph;
paragraph = (char**)malloc(1*sizeof(char*));
int position=0;
if ((fd = opendir(dir)) == NULL) {
syslog(LOG_INFO,"Error, no se pudo abrir el directorio /var/log");
closelog();
return;
}
while ((dp = readdir(fd)) != NULL) {
if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
continue; /* skip self and parent */
char *aux = get_filename_ext(dp->d_name);
// printf("Val--------> %d type dir %d type file regular %d\n ",dp->d_type,DT_DIR,DT_REG);
if(dp->d_type == DT_REG){
if(strcmp(aux,"gz")!=0){
//agregar a la lista
paragraph = ObtenerPalabras(dp->d_name,paragraph,position);
position++;
}
}
}
(void) signal(SIGUSR1,manejadorDeSenales);
int pos=0;
//printf("Num pal %d\n",position);
for(pos; pos < position; pos++){
int i, fds[2];
if (pipe(fds) == -1) {
syslog(LOG_ERR,"Error, no se pudo crear la tuberia anonima");
exit(EXIT_FAILURE);
}
pmd5sum = fork();
if (pmd5sum == 0) {
hijo(fds,paragraph[pos]);
kill(pmd5sum,SIGKILL);
} else if (pmd5sum > 0) {
/* tratamiento del padre */
papa(fds);
close(fds[0]);
close(fds[1]);
kill(pmd5sum,SIGKILL);
} else if (pmd5sum == -1) {
syslog(LOG_ERR,"Error, fallo en la llamada fork");
exit(EXIT_FAILURE);
}
/* tratamiento del padre una vez lanzado su hijo. */
pmd5sum = wait(NULL);
while (pmd5sum > 0) {
pmd5sum = wait(NULL);
}
if (pmd5sum == -1 && errno != ECHILD) {
syslog(LOG_ERR,"Error, fallo en la llamada wait");
exit(EXIT_FAILURE);
}
}//fin for que crea hijos
// libero el paragragh
memset(paragraph,0,sizeof(char*)*position);
// visualizacion(lista);
// verifico si algun archivo cambio llamando a cambio ?
char *namepak;
int cambio = file_change(lista);
if(cambio==1){//algun archivo cambio
//procesar .pak
namepak = (char*)proccesingPak(lista);
set_change(lista);
pgzip = fork();
if (pgzip == 0) {
comprimir(namepak);
kill(pgzip,SIGKILL);
} else if (pgzip > 0) {
/* tratamiento del padre */
pgzip = wait(NULL);
while (pgzip > 0) {
pgzip = wait(NULL);
}
}else if (pgzip == -1) {
syslog(LOG_ERR,"Error, fallo en fork");
exit(EXIT_FAILURE);
}
if (pgzip == -1 && errno != ECHILD) {
syslog(LOG_ERR,"Error, fallo en wait");
exit(EXIT_FAILURE);
}
}//FIN IF CAMBIO
}//FIN WHILE TRUE
}//FIN MAIN
/*!
\fn Ebackup::generar_config()
Genera un una copia de los valores de configuracion del programa y los prepara para la compresion.
*/
bool Ebackup::generar_config()
{
preferencias *p = preferencias::getInstancia();
// Obtengo todas las claves
QStringList claves = p->allKeys();
PBProgreso->setRange( 0, ( claves.size() * 2 ) + 2 );
PBProgreso->setValue( 0 );
// Genero los datos concatenando las variables
// Inicio de preferencias
// Cabecera de los datos
datos->append("|->preferencias->");
// bucle que recorre cada valor
QStringList::const_iterator iterador;
for( iterador = claves.constBegin(); iterador != claves.constEnd(); ++iterador )
{
if( !_continuar )
{ return false; }
datos->append( (*iterador).toLocal8Bit().constData() );
PBProgreso->setValue( PBProgreso->value() + 1 );
datos->append( "=" );
// Separador de valores
QVariant v = p->value( (*iterador), QVariant() );
QString result;
switch( v.type() )
{
///////////////////////////////////////////////////////////////////////////
// Copiado desde la clase qsettings de qt
case QVariant::Invalid:
{
result = QLatin1String("@Invalid()");
break;
}
case QVariant::ByteArray:
{
QByteArray a = v.toByteArray();
result = QLatin1String("@ByteArray(");
result += QString::fromLatin1(a.constData(), a.size());
result += QLatin1Char(')');
break;
}
case QVariant::String:
case QVariant::LongLong:
case QVariant::ULongLong:
case QVariant::Int:
case QVariant::UInt:
case QVariant::Bool:
case QVariant::Double:
case QVariant::KeySequence: {
result = v.toString();
if (result.startsWith(QLatin1Char('@')))
result.prepend(QLatin1Char('@'));
break;
}
case QVariant::Rect: {
QRect r = qvariant_cast<QRect>(v);
result += QLatin1String("@Rect(");
result += QString::number(r.x());
result += QLatin1Char(' ');
result += QString::number(r.y());
result += QLatin1Char(' ');
result += QString::number(r.width());
result += QLatin1Char(' ');
result += QString::number(r.height());
result += QLatin1Char(')');
break;
}
case QVariant::Size: {
QSize s = qvariant_cast<QSize>(v);
result += QLatin1String("@Size(");
result += QString::number(s.width());
result += QLatin1Char(' ');
result += QString::number(s.height());
result += QLatin1Char(')');
break;
}
case QVariant::Point: {
QPoint p = qvariant_cast<QPoint>(v);
result += QLatin1String("@Point(");
result += QString::number(p.x());
result += QLatin1Char(' ');
result += QString::number(p.y());
result += QLatin1Char(')');
break;
}
default: {
QByteArray a;
{
QDataStream s(&a, QIODevice::WriteOnly);
s.setVersion(QDataStream::Qt_4_0);
s << v;
}
result = QLatin1String("@Variant(");
result += QString::fromLatin1(a.constData(), a.size());
result += QLatin1Char(')');
break;
}
//////////////////////////////////////////////////////////////////////////////
}
datos->append( result );
PBProgreso->setValue( PBProgreso->value() + 1 );
// Separador de preferencia
datos->append( "\n" );
}
// fin de los datos
datos->append("<-preferencias<-|");
// Comprimo los datos y los envio al buffer de comprimidos
LDebug->setText( LDebug->text() + "... Comprimiendo.... " );
comprimir();
PBProgreso->setValue( PBProgreso->value() + 1 );
// Limpio el buffer asi se libera la memoria
LDebug->setText( LDebug->text() + "... Limpiando.... " );
datos->clear();
PBProgreso->setValue( PBProgreso->value() + 1 );
LDebug->setText( "Listo backup de configuracion" );
return true;
}
