Lo hice pero actualmente solo
para un solo archivo eml, ya que me da flojera hacerlo para todo un directorio y que busque los archivos eml etc etc etc...
Lo hice en C. se que este es el subforo de VB, pero la verdad VB no me gusta mucho para este tipo de operaciones, de hechos me gusta el VBA para automatizar trabajos en Excel
Imagen de prueba que funciona:
Y el archivo se crea en el directorio pasado como segundo parametro.
Por cierto si el siguiente código fuente si se compila en algunos compiladores de Windows puede dar muchos warning, pero con gcc de MinGW no me tira ningun warning ni error como esta en la imagen.
/*
gcc -o dump_eml.exe dump_eml_attachments.c
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdint.h>
static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'};
static char *decoding_table = NULL;
static int mod_table[] = {0, 2, 1};
unsigned char *base64_decode(const char *data,
size_t input_length,
size_t *output_length);
void build_decoding_table();
void base64_cleanup();
int open_and_extract_from_eml(char *filename,char *path_destino);
int isEmptyLine(char *line);
char *content_disposition = "Content-Disposition: attachment;";
int main(int argc, char **argv ) {
if(argc != 3) {
printf("Uso: %s <Carpeta_con_EMLs> <Carpeta_destino_adjuntos>\n",argv
[0]); }
open_and_extract_from_eml(argv[1],argv[2]);
return 0;
}
int open_and_extract_from_eml(char *filename,char *path_destino) {
FILE *eml_file, *temp_file;
char *dest_file,*temp0,*temp1;
char *line,*buffer_base64 = NULL,*buffer_decoded;
char *full_writen_file;
int len_dest_file_name,offset,len_content_disposition,len_base64_line,len_base64_buffer, len_output,len_path_destino,entrar;
len_content_disposition
= strlen(content_disposition
); len_path_destino
= strlen(path_destino
); eml_file
= fopen(filename
,"rb"); offset = 0;
while(!feof(eml_file
) && fgets(line
,1024,eml_file
) != NULL
) { if(memcmp(line
,content_disposition
,len_content_disposition
) == 0) { printf("Encontrado: %s",line
); temp0
= strstr(line
,"filename="); if(temp0 ==NULL ) {
//tal vez la proxima linea?
fgets(line
,1024,eml_file
); }
temp0
= strstr(line
,"filename="); if(temp0 !=NULL ) {
temp1
= strstr(temp0
+10,"\""); if(temp1 == NULL) {
//No hay " finales
}
len_dest_file_name = temp1 - (line + (temp0 - line) + 10 );
//printf("len_dest_file_name %i\n",len_dest_file_name);
dest_file
= malloc(len_dest_file_name
+1); strncpy(dest_file
,(line
+ (temp0
- line
) + 10),len_dest_file_name
); dest_file[len_dest_file_name] = '\0';
fgets(line
,1024,eml_file
); //printf("Nueva linea leida \"%s\"",line);
if(!isEmptyLine(line)) {
//Deberia de ser una linea vacia;
}
buffer_base64 = NULL;
offset = 0;
entrar = 1;
while(entrar
&& fgets(line
,1024,eml_file
) != NULL
&& !isEmptyLine
(line
) ) { //leemos hasta la proxima linea vacia o hasta encontrar un '=' al final de la linea len_base64_line
= strlen(line
); buffer_base64
= realloc(buffer_base64
,offset
+len_base64_line
+1); if(line[len_base64_line-1] == '\n' || line[len_base64_line-1] == '\r'){
line[len_base64_line-1] ='\0';
len_base64_line--;
}
if(line[len_base64_line-1] == '\n' || line[len_base64_line-1] == '\r'){
line[len_base64_line-1] ='\0';
len_base64_line--;
}
memcpy(buffer_base64
+offset
,line
,len_base64_line
); offset+=len_base64_line;
if(line[len_base64_line-1] == '=') {
entrar = 0;
}
}
buffer_base64[offset] = '\0';
//printf("Encoded buffer: %s\n",buffer_base64);
len_base64_buffer
= strlen(buffer_base64
); buffer_decoded = base64_decode(buffer_base64,len_base64_buffer,&len_output);
buffer_decoded[len_output] = '\0';
/*
printf("OK\n");
printf("Decoded buffer: %s\n",buffer_decoded);
printf("Path destino: %s\n",path_destino);
printf("len_dest_file_name: %i\n",len_dest_file_name);
printf("len_path_destino: %i\n",len_path_destino);
*/
full_writen_file
= malloc(len_dest_file_name
+ len_path_destino
+10); sprintf(full_writen_file
,"%s/%s",path_destino
,dest_file
); printf("Destino: %s\n",full_writen_file
); temp_file
= fopen(full_writen_file
,"wb"); fwrite(buffer_decoded
,1,len_output
,temp_file
);
}
else {
printf("Se encontro %s, pero no se encontro Filename omitiendo!\n",content_disposition
); }
}
}
}
int isEmptyLine(char *line) {
if(line[0] == '\0' || line[0] == '\n' || line[0] == '\r')
return 1;
return 0;
}
unsigned char *base64_decode(const char *data,
size_t input_length,
size_t *output_length) {
if (decoding_table == NULL) build_decoding_table();
if (input_length % 4 != 0) return NULL;
*output_length = input_length / 4 * 3;
if (data[input_length - 1] == '=') (*output_length)--;
if (data[input_length - 2] == '=') (*output_length)--;
unsigned char *decoded_data
= malloc(*output_length
); if (decoded_data == NULL) return NULL;
for (int i = 0, j = 0; i < input_length;) {
uint32_t sextet_a = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
uint32_t sextet_b = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
uint32_t sextet_c = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
uint32_t sextet_d = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
uint32_t triple = (sextet_a << 3 * 6)
+ (sextet_b << 2 * 6)
+ (sextet_c << 1 * 6)
+ (sextet_d << 0 * 6);
if (j < *output_length) decoded_data[j++] = (triple >> 2 * 8) & 0xFF;
if (j < *output_length) decoded_data[j++] = (triple >> 1 * 8) & 0xFF;
if (j < *output_length) decoded_data[j++] = (triple >> 0 * 8) & 0xFF;
}
return decoded_data;
}
void build_decoding_table() {
for (int i = 0; i < 64; i++)
decoding_table[(unsigned char) encoding_table[i]] = i;
}
void base64_cleanup() {
}
El programa lo puedes utilizar para todo un directorio pero con ayuda de batch creo recordar que existe una instrucción for que te ayuda a procesar todos los archivos de un subdirectorio y pasarlos a un programa.
Saludos!
Mostrar Mensajes
