Changeset 1355

Show
Ignore:
Timestamp:
08/21/07 11:23:47 (1 year ago)
Author:
till
Message:

- fix: corrected error in logical expression when searching for default responses
- fix: passing errors to errno when a non-blocking connect fails
- switched to the more flexible sigaction() instead of signal()
- improved ngrie's performance: reallocating arrays as trie nodes seems to be a fast solution

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • honeytrap/trunk/configure.in

    r1334 r1355  
    541541        AC_CHECK_LIB(efence, EF_ALIGNMENT, LIBS="${LIBS} -lefence", AC_MSG_ERROR(libefence not found)) 
    542542else 
    543         with_efence="no" 
     543        with_efence=" " 
    544544fi 
    545545 

  • honeytrap/trunk/src/attack.c

    r1286 r1355  
    5050        a->download             = NULL; 
    5151        if (time(&(a->start_time)) == ((time_t)-1))  
    52                 logmsg(LOG_WARN, 1, "Warning - Could not set attack start time: %s.\n", strerror(errno)); 
     52                logmsg(LOG_WARN, 1, "Warning - Could not set attack start time: %m.\n"); 
    5353 
    5454        return(a); 
    …… 
    6767        /* save end time and payload data in attack record */ 
    6868        if (time(&(a->end_time)) == ((time_t)-1))  
    69                 logmsg(LOG_WARN, 1, "Warning - Could not set attack end time: %s.\n", strerror(errno)); 
     69                logmsg(LOG_WARN, 1, "Warning - Could not set attack end time: %m.\n"); 
    7070 
    7171        /* attack string */ 
    …… 
    123123 
    124124        if ((a->download = realloc(a->download, sizeof(struct s_download) * (a->dl_count + 1))) == NULL) { 
    125                 logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %s.\n", strerror(errno)); 
     125                logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n"); 
    126126                return(-1); 
    127127        } 
    …… 
    132132            (pass && ((a->download[a->dl_count].pass = strdup(pass)) == NULL)) || 
    133133            ((a->download[a->dl_count].dl_payload.data = (u_char *) malloc(size)) == NULL)) {  
    134                 logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %s.\n", strerror(errno)); 
     134                logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n"); 
    135135                free(a->download[a->dl_count].dl_type); 
    136136                free(a->download[a->dl_count].user); 

  • honeytrap/trunk/src/conftree.c

    r1286 r1355  
    9393        /* create new element */ 
    9494        if ((new_entry = malloc(sizeof(list_entry))) == NULL) { 
    95                 logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %s.\n", strerror(errno)); 
     95                logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n"); 
    9696                return(NULL); 
    9797        } 
    …… 
    100100        /* copy data */ 
    101101        if ((new_entry->data = malloc(size+1)) == NULL) { 
    102                 logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %s.\n", strerror(errno)); 
     102                logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n"); 
    103103                return(NULL); 
    104104        } 
    …… 
    143143 
    144144        if (((key = (char **) malloc(sizeof(char *))) == NULL) || ((*key = strdup(keyword)) ==  NULL)) { 
    145                 fprintf(stderr, "  Error - Unable to allocate memory: %s.\n", strerror(errno)); 
     145                fprintf(stderr, "  Error - Unable to allocate memory: %m.\n"); 
    146146                return(NULL); 
    147147        } 
    …… 
    185185        // check whether a prefix does already exist and if not, add it recursively 
    186186        if ((key = strdup(keyword)) ==  NULL) { 
    187                 logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %s.\n", strerror(errno)); 
     187                logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n"); 
    188188                return(NULL); 
    189189        } 
    …… 
    209209        // create new node and insert it into tree 
    210210        if ((new_node = malloc(sizeof(conf_node))) == NULL) { 
    211                 logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %s.\n", strerror(errno)); 
     211                logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n"); 
    212212                free(key); 
    213213                return(NULL); 
    …… 
    216216        // if keyword is a toplevel key, add it, else add subkey 
    217217        if ((new_node->keyword = strdup(subkey ? subkey : key)) == NULL) { 
    218                 logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %s.\n", strerror(errno)); 
     218                logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n"); 
    219219                free(key); 
    220220                return(NULL); 

  • honeytrap/trunk/src/ctrl.c

    r1345 r1355  
    7373                logmsg(LOG_DEBUG, 1, "Unlocking pid file.\n"); 
    7474                if (lockf(pidfile_fd, F_ULOCK, 0) < 0)  
    75                         logmsg(LOG_ERR, 1, "Error - Unable to unlock pid file: %s.\n", strerror(errno)); 
     75                        logmsg(LOG_ERR, 1, "Error - Unable to unlock pid file: %m.\n"); 
    7676 
    7777                logmsg(LOG_DEBUG, 1, "Closing pid file.\n"); 
    7878                if (close(pidfile_fd) == -1) 
    79                         logmsg(LOG_ERR, 1, "Error - Unable to close pid file: %s.\n", strerror(errno)); 
     79                        logmsg(LOG_ERR, 1, "Error - Unable to close pid file: %m.\n"); 
    8080 
    8181                logmsg(LOG_DEBUG, 1, "Removing pid file.\n"); 
    8282                if (unlink(pidfile_name) == -1) 
    83                         logmsg(LOG_ERR, 1, "Error - Unable to remove pid file: %s.\n", strerror(errno)); 
     83                        logmsg(LOG_ERR, 1, "Error - Unable to remove pid file: %m.\n"); 
    8484        } else logmsg(LOG_DEBUG, 1, "No pid file installed.\n"); 
    8585 
    8686        logmsg(LOG_NOTICE, 1, "---- honeytrap stopped ----\n"); 
    8787         
    88         if (close(logfile_fd) == -1) logmsg(LOG_ERR, 1, "Error - Unable to close logfile: %s.\n", strerror(errno)); 
     88        if (close(logfile_fd) == -1) logmsg(LOG_ERR, 1, "Error - Unable to close logfile: %m.\n"); 
    8989 
    9090        exit(status); 
    …… 
    108108 
    109109        if (getrlimit(RLIMIT_NOFILE, &rl) < 0) { 
    110                 fprintf(stderr, "  Error - Unable to daemonize: %s\n", strerror(errno)); 
     110                fprintf(stderr, "  Error - Unable to daemonize: %m.\n"); 
    111111                exit(EXIT_FAILURE); 
    112112        } 
    …… 
    114114        /* become session leader and loose controlling TTY */ 
    115115        if ((pid = myfork()) < 0) { 
    116                 fprintf(stderr, "  Error - Unable to daemonize: %s\n", strerror(errno)); 
     116                fprintf(stderr, "  Error - Unable to daemonize: %m.\n"); 
    117117                exit(EXIT_FAILURE); 
    118118        } else if (pid != 0) exit(EXIT_SUCCESS); 
    …… 
    122122        /* fork again, future opens must not allocate controlling TTYs */ 
    123123        if ((pid = myfork()) < 0) { 
    124                 fprintf(stderr, "  Error - Unable to daemonize: %s\n", strerror(errno)); 
     124                fprintf(stderr, "  Error - Unable to daemonize: %m.\n"); 
    125125                exit(EXIT_FAILURE); 
    126126        } else if (pid != 0) { 
    …… 
    135135        DEBUG_FPRINTF(stdout, "  Current working directory is %s, changing it to /.\n", old_cwd); 
    136136        if (chdir("/") < 0) { 
    137                 fprintf(stderr, "  Error - Cannot change working directory: %s\n", strerror(errno)); 
     137                fprintf(stderr, "  Error - Cannot change working directory: %m.\n"); 
    138138                exit(EXIT_FAILURE); 
    139139        } 
    …… 
    144144        for (i=0; i < rl.rlim_max; i++) 
    145145                if ((i != logfile_fd) && (i != sigpipe[0]) && (i != sigpipe[1]) && (close(i) == -1)) 
    146                         fprintf(stdout, "  Warnging - Could not close file descriptor %d: %s.\n", i, strerror(errno)); 
     146                        fprintf(stdout, "  Warnging - Could not close file descriptor %d: %m.\n", i); 
    147147 
    148148        /* attach file descriptors 0, 1 and 2 to /dev/null to prevent accidentally standard IO */ 
    149149        if ((fd0 = open("/dev/null", O_RDWR)) == -1) { 
    150                 fprintf(stderr, "  Error - Unable to set stdin to /dev/null: %s.\n", strerror(errno)); 
     150                fprintf(stderr, "  Error - Unable to set stdin to /dev/null: %m.\n"); 
    151151                exit(EXIT_FAILURE); 
    152152        } 
    153153        if ((fd1 = dup(fd0)) == -1) { 
    154                 fprintf(stderr, "  Error - Unable to set stdout to /dev/null: %s.\n", strerror(errno)); 
     154                fprintf(stderr, "  Error - Unable to set stdout to /dev/null: %m.\n"); 
    155155                exit(EXIT_FAILURE); 
    156156        } 
    157157        if ((fd2 = dup(fd0)) == -1) { 
    158                 fprintf(stderr, "  Error - Unable to set stderr to /dev/null: %s.\n", strerror(errno)); 
     158                fprintf(stderr, "  Error - Unable to set stderr to /dev/null: %m.\n"); 
    159159                exit(EXIT_FAILURE); 
    160160        } 
    …… 
    170170 
    171171        if ((pidfile_fd = open(pidfile_name, O_EXCL | O_CREAT | O_NOCTTY | O_RDWR, 0640)) == -1) { 
    172                 logmsg(LOG_ERR, 1, "Error - Unable to open pid file: %s\n", strerror(errno)); 
     172                logmsg(LOG_ERR, 1, "Error - Unable to open pid file: %m.\n"); 
    173173                exit(EXIT_SUCCESS); 
    174174        } 
    175175        if (lockf(pidfile_fd, F_TLOCK, 0) < 0) { 
    176                 logmsg(LOG_ERR, 1, "Error - Unable to lock pid file: %s\n", strerror(errno)); 
     176                logmsg(LOG_ERR, 1, "Error - Unable to lock pid file: %m.\n"); 
    177177                clean_exit(EXIT_SUCCESS); 
    178178        } 
    179179 
    180         parent_pid = getpid(); 
     180        master_pid = getpid(); 
    181181 
    182182        bzero(pid_str, 5); 
    183         snprintf(pid_str, 5,"%d\n", parent_pid); 
     183        snprintf(pid_str, 5,"%d\n", master_pid); 
    184184        if (!(write(pidfile_fd, pid_str, strlen(pid_str)))) { 
    185                 logmsg(LOG_ERR, 1, "Error - Unable to write pid file: %s\n", strerror(errno)); 
     185                logmsg(LOG_ERR, 1, "Error - Unable to write pid file: %m.\n"); 
    186186                return(0); 
    187187        } 

  • honeytrap/trunk/src/dynsrv.c

    r1354 r1355  
    131131                /* a backlog queue size of 10 should give us enough time to fork */ 
    132132                if ((proto == TCP) && ((listen(listen_fd, 10)) < 0)) { 
    133                         logmsg(LOG_ERR, 1, "Error - Could not listen on socket: %s.\n", strerror(errno)); 
     133                        logmsg(LOG_ERR, 1, "Error - Could not listen on socket: %m.\n"); 
    134134                        close(listen_fd); 
    135135                        exit(EXIT_FAILURE); 
    …… 
    157157                 * that it's just the passed-through value of a sendmsg() */ 
    158158                if (nfq_set_verdict(qh, id, NF_ACCEPT, 0, NULL) == -1) { 
    159                         logmsg(LOG_ERR, 1, "Error - Could not set verdict on packet: %s.\n", strerror(errno)); 
     159                        logmsg(LOG_ERR, 1, "Error - Could not set verdict on packet: %m.\n"); 
    160160                        nfq_destroy_queue(qh); 
    161161                        exit(EXIT_FAILURE); 
    …… 
    184184                                } 
    185185                                logmsg(LOG_ERR, 1, 
    186                                        "   %s  Error - select() call failed: %s.\n", portstr, strerror(errno)); 
     186                                       "   %s  Error - select() call failed: %m.\n", portstr); 
    187187                                exit(EXIT_FAILURE); 
    188188                        case 0: 
    …… 
    221221                                                        else { 
    222222                                                                logmsg(LOG_ERR, 1, 
    223                                                                        "   %s  Error - Could not accept tcp connection: %s\n", 
    224                                                                        portstr, strerror(errno)); 
     223                                                                       "   %s  Error - Could not accept tcp connection: %m.\n", 
     224                                                                       portstr); 
    225225                                                                close(mirror_sock_fd); 
    226226                                                                free(attack); 
    …… 
    244244                                                        else { 
    245245                                                                logmsg(LOG_ERR, 1, 
    246                                                                        "   %s  Error - Could not connect udp socket: %s\n", 
    247                                                                        portstr, strerror(errno)); 
     246                                                                       "   %s  Error - Could not connect udp socket: %m.\n", 
     247                                                                       portstr); 
    248248                                                                close(mirror_sock_fd); 
    249249                                                                free(attack); 
    …… 
    260260                                                        else { 
    261261                                                                logmsg(LOG_ERR, 1, 
    262                                                                        "   %s  Error - Could not get remote host information: %s\n", 
    263                                                                        portstr, strerror(errno)); 
     262                                                                       "   %s  Error - Could not get remote host information: %m.\n", 
     263                                                                       portstr); 
    264264                                                                close(mirror_sock_fd); 
    265265                                                                free(attack); 
    …… 
    415415                } // for - incoming connections 
    416416        } /* fork - server process */ 
    417         else if (pid == -1) logmsg(LOG_ERR, 1, "Error - Forking server process failed: %s.\n", strerror(errno)); 
     417        else if (pid == -1) logmsg(LOG_ERR, 1, "Error - Forking server process failed: %m.\n"); 
    418418        return; 
    419419} 
    …… 
    444444                                break; 
    445445                        } 
    446                         logmsg(LOG_ERR, 1, "   %s  Error - select() failed: %s.\n", portstr, strerror(errno)); 
     446                        logmsg(LOG_ERR, 1, "   %s  Error - select() failed: %m.\n", portstr); 
    447447                        close(connection_fd); 
    448448                        return(process_data(attack_string, total_bytes, NULL, 0, attack->a_conn.l_port, attack)); 
    …… 
    459459                                if ((!send_default_response(connection_fd, port, proto, read_timeout)) == -1) { 
    460460                                        logmsg(LOG_ERR, 1, 
    461                                                "   %s  Error - Sending response failed: %s.\n", 
    462                                                portstr, strerror(errno)); 
     461                                               "   %s  Error - Sending response failed: %m.\n", portstr); 
    463462                                        close(connection_fd); 
    464463                                        return(process_data 
    …… 
    476475                                        if (!(attack_string = (u_char *) realloc(attack_string, total_bytes))) { 
    477476                                                logmsg(LOG_ERR, 1, 
    478                                                        "   %s  Error - Reallocating buffer size failed: %s.\n", 
    479                                                        portstr, strerror(errno)); 
     477                                                       "   %s  Error - Reallocating buffer size failed: %m.\n", portstr); 
    480478                                                free(attack_string); 
    481479                                                exit(EXIT_FAILURE); 
    …… 
    501499                                                (attack_string, total_bytes, NULL, 0, attack->a_conn.l_port, attack)); 
    502500                                } else { 
    503                                         logmsg(LOG_NOISY, 1, "   %s  Could not read data: %s.\n", portstr, strerror(errno)); 
     501                                        logmsg(LOG_NOISY, 1, "   %s  Could not read data: %m.\n", portstr); 
    504502                                        close(connection_fd); 
    505503                                        return(process_data 
    …… 
    559557                                break; 
    560558                        } 
    561                         logmsg(LOG_INFO, 1, "%s %s  Error - Select failed: %s.\n", logpre, portstr, strerror(errno)); 
     559                        logmsg(LOG_INFO, 1, "%s %s  Error - Select failed: %m.\n", logpre, portstr); 
    562560                        shutdown(server_sock_fd, SHUT_RDWR); 
    563561                        shutdown(connection_fd, SHUT_RDWR); 

  • honeytrap/trunk/src/honeytrap.c

    r1292 r1355  
    8484 
    8585 
    86         /* install signal handlers */ 
    87         install_signal_handlers(); 
    88          
    89  
    9086        /* configure honeytrap */ 
    9187        configure(arg_c, arg_v); 

  • honeytrap/trunk/src/honeytrap.h

    r1354 r1355  
    7373 
    7474int pidfile_fd, first_init; 
    75 pid_t parent_pid; 
    7675char old_cwd[1024]; 
    7776 

  • honeytrap/trunk/src/ipqmon.c

    r1292 r1355  
    8484                        } 
    8585                        /* error */ 
    86                         logmsg(LOG_ERR, 1, "Error - select() call failed in main loop: %s.\n", strerror(errno)); 
     86                        logmsg(LOG_ERR, 1, "Error - select() call failed in main loop: %m.\n"); 
    8787                        exit(EXIT_FAILURE); 
    8888                case 0: 

  • honeytrap/trunk/src/nfqmon.c

    r1292 r1355  
    148148        logmsg(LOG_DEBUG, 1, "Creating NFQ connection monitor.\n"); 
    149149        if ((h = nfq_open()) < 0) { 
    150                 logmsg(LOG_ERR, 1, "Error - Could not create NFQ handle: %s\n", strerror(errno)); 
     150                logmsg(LOG_ERR, 1, "Error - Could not create NFQ handle: %m.\n"); 
    151151                clean_exit(EXIT_FAILURE); 
    152152        } 
    153153 
    154154        if (nfq_unbind_pf(h, AF_INET) < 0) { 
    155                 logmsg(LOG_ERR, 1, "Error - Could not unbind existing NFQ handle: %s\n", strerror(errno)); 
     155                logmsg(LOG_ERR, 1, "Error - Could not unbind existing NFQ handle: %m.\n"); 
    156156                logmsg(LOG_ERR, 1, "Do you have root privileges?\n"); 
    157157                clean_exit(EXIT_FAILURE); 
    …… 
    159159 
    160160        if (nfq_bind_pf(h, AF_INET) < 0) { 
    161                 logmsg(LOG_ERR, 1, "Error - Could not bind existing NFQ handle: %s\n", strerror(errno)); 
     161                logmsg(LOG_ERR, 1, "Error - Could not bind existing NFQ handle: %m.\n"); 
    162162                clean_exit(EXIT_FAILURE); 
    163163        } 
    164164 
    165165        if ((qh = nfq_create_queue(h,  0, &server_wrapper, NULL)) == NULL) { 
    166                 logmsg(LOG_ERR, 1, "Error - Could not create NFQ queue handle: %s\n", strerror(errno)); 
     166                logmsg(LOG_ERR, 1, "Error - Could not create NFQ queue handle: %m.\n"); 
    167167                clean_exit(EXIT_FAILURE); 
    168168        } 
    …… 
    197197                        } 
    198198                        /* error */ 
    199                         logmsg(LOG_ERR, 1, "Error - select() call failed in main loop: %s.\n", strerror(errno)); 
     199                        logmsg(LOG_ERR, 1, "Error - select() call failed in main loop: %m.\n"); 
    200200                        exit(EXIT_FAILURE); 
    201201                case 0: 

  • honeytrap/trunk/src/parseconf.c

    r1270 r1355  
    190190static enum lcfg_status lcfg_scanner_buffer_fill(struct lcfg_scanner *s) { 
    191191        if( (s->size = read(s->fd, s->buffer, LCFG_BUFSIZ)) < 0 ) { 
    192                 lcfg_error_set(s->lcfg, "read(): %s", strerror(errno)); 
     192                lcfg_error_set(s->lcfg, "read(): %m"); 
    193193                return lcfg_status_error; 
    194194        } else if( s->size == 0 ) s->eof = !0; 
    …… 
    582582                        if( t.type == lcfg_string ) { 
    583583                                lcfg_parser_add_value(p, lcfg_string_cstr(current_path), t.string); 
    584                                 /*printf("adding string value for single statement\n");*/ 
    585584                                STATE_STACK_POP(); 
    586585                                PATH_POP(); 
    …… 
    599598                                lcfg_parser_add_value(p, lcfg_string_cstr(current_path), t.string); 
    600599                                PATH_POP(); 
    601                                 /*printf("adding string to list pos %d\n", state_stack[ssi].list_counter);*/ 
    602600                                state_stack[ssi].list_counter++; 
    603601                        } else if( t.type == lcfg_sbracket_open ) { 
    604602                                PATH_PUSH_INT(state_stack[ssi].list_counter); 
    605                                 /*printf("adding list to list pos %d\n", state_stack[ssi].list_counter);*/ 
    606603                                state_stack[ssi].list_counter++; 
    607604                                STATE_STACK_PUSH(in_list); 
    608605                        } else if( t.type == lcfg_brace_open ) { 
    609606                                PATH_PUSH_INT(state_stack[ssi].list_counter); 
    610                                 /*printf("adding map to list pos %d\n", state_stack[ssi].list_counter);*/ 
    611607                                state_stack[ssi].list_counter++; 
    612608                                STATE_STACK_PUSH(in_map); 
    …… 
    625621                 
    626622                lcfg_string_delete(t.string); 
    627                  
    628                 /*printf(" *** pda: read %s, state is now %s\n", lcfg_token_map[t.type], state_map[state_stack[ssi].s]);*/ 
    629623        } 
    630624 
    …… 
    645639         
    646640        if( fd < 0 ) { 
    647                 lcfg_error_set(p->lcfg, "open(): %s", strerror(errno)); 
     641                lcfg_error_set(p->lcfg, "open(): %m"); 
    648642                return lcfg_status_error; 
    649643        } 

  • honeytrap/trunk/src/pcapmon.c

    r1292 r1355  
    267267                        } 
    268268                        /* error */ 
    269                         logmsg(LOG_ERR, 1, "Error - select() call failed in main loop: %s.\n", strerror(errno)); 
     269                        logmsg(LOG_ERR, 1, "Error - select() call failed in main loop: %m.\n"); 
    270270                        exit(EXIT_FAILURE); 
    271271                case 0: 
    …… 
    380380                if (!(bpf_filter_string = (char *)realloc(bpf_filter_string, 
    381381                        strlen(bpf_filter_string)+strlen(bpf_cmd_ext)+8))) { 
    382                         fprintf(stderr, "  Error - Unable to allocate memory: %s\n", strerror(errno)); 
     382                        fprintf(stderr, "  Error - Unable to allocate memory: %m.\n"); 
    383383                        exit(EXIT_FAILURE); 
    384384                }        

  • honeytrap/trunk/src/plughook.c

    r1292 r1355  
    5353                /* assemble full config option path */ 
    5454                if ((confopt = malloc(strlen(full_name)+strlen(keywords[i])+2)) == NULL) { 
    55                         fprintf(stderr, "  Error - Unable to allocate memory: %s.\n", strerror(errno)); 
     55                        fprintf(stderr, "  Error - Unable to allocate memory: %m.\n"); 
    5656                        exit(EXIT_FAILURE); 
    5757                } 
    …… 
    8080        DEBUG_FPRINTF(stdout, "    Hooking %s::%s() to 'process_attack' (priority: %d).\n", plugname, funcname, priority); 
    8181        if ((func_new = (PlugFuncList *) malloc(sizeof(PlugFuncList))) == NULL) { 
    82                 logmsg(LOG_ERR, 1, "    Error - Unable to allocate memory: %s\n", strerror(errno)); 
     82                logmsg(LOG_ERR, 1, "    Error - Unable to allocate memory: %m.\n"); 
    8383                return(NULL); 
    8484        } 
    …… 
    153153        DEBUG_FPRINTF(stdout, "    Hooking plugin %s to 'unload_plugins'.\n", plugname); 
    154154        if ((func_new = (PlugFuncList *) malloc(sizeof(PlugFuncList))) == NULL) { 
    155                 logmsg(LOG_ERR, 1, "    Error - Unable to allocate memory: %s\n", strerror(errno)); 
     155                logmsg(LOG_ERR, 1, "    Error - Unable to allocate memory: %m.\n"); 
    156156                return(NULL); 
    157157        } 

  • honeytrap/trunk/src/plugin.c

    r1292 r1355  
    4949 
    5050        if ((plugindir = opendir(dir)) == NULL) { 
    51                 fprintf(stderr, "  Error - Unable to open plugin directory: %s.\n", strerror(errno)); 
     51                fprintf(stderr, "  Error - Unable to open plugin directory: %m.\n"); 
    5252                exit(EXIT_FAILURE); 
    5353        } 
    …… 
    5555        DEBUG_FPRINTF(stdout, "  Looking for plugin %s in %s\n", plugname, dir); 
    5656        if ((n = scandir(dir, &namelist, 0, alphasort)) < 0) { 
    57                 fprintf(stderr, "  Error - Unable to scan plugin directory: %s\n", strerror(errno)); 
     57                fprintf(stderr, "  Error - Unable to scan plugin directory: %m.\n"); 
    5858                return(-1); 
    5959        } else while(n--) { 
    …… 
    8282        } 
    8383        if (ret != 0) { 
    84                 fprintf(stderr, "  Error - Unable to load plugin %s: %s.\n", full_name, strerror(errno)); 
     84                fprintf(stderr, "  Error - Unable to load plugin %s: %m.\n", full_name); 
    8585                exit(EXIT_FAILURE); 
    8686        } 
    …… 
    9898        /* allocate memory for new plugin and attach it to the plugin list */ 
    9999        if ((new_plugin = (Plugin *) malloc(sizeof(Plugin))) == NULL) { 
    100                 fprintf(stderr, "    Error - Unable to allocate memory: %s\n", strerror(errno)); 
     100                fprintf(stderr, "    Error - Unable to allocate memory: %m.\n"); 
    101101                return(-1); 
    102102        } else { 
    …… 
    113113        } else {  
    114114                if ((new_plugin->handle = (void *) malloc(sizeof(int))) == NULL) {  
    115                         fprintf(stderr, "  Error loading plugin - Unable to allocate memory: %s\n", strerror(errno)); 
     115                        fprintf(stderr, "  Error loading plugin - Unable to allocate memory: %m.\n"); 
    116116                        free(new_plugin); 
    117117                        return(-1); 

  • honeytrap/trunk/src/proxy.c

    r1345 r1355  
    1919#include <strings.h> 
    2020#include <sys/socket.h> 
    21 //#include <unistd.h> 
    2221 
    2322#include "honeytrap.h" 
    …… 
    9594                       sizeof(proxy_socket), timeout)) { 
    9695                case -1: 
    97                         if (errno == EINPROGRESS) break; 
    98                         if (errno == EINTR) { 
     96                        switch(errno) { 
     97                        case EINPROGRESS: 
     98                                break; 
     99                        case EINTR: 
    99100                                if (check_sigpipe() == -1) exit(EXIT_FAILURE); 
    100101                                break; 
     102                        case ECONNREFUSED: 
     103                                logmsg(LOG_DEBUG, 1, "%s %s  select() call failed: %m.\n", 
     104                                        logpre, portstr); 
     105                                return(-1); 
     106                        default: 
     107                                logmsg(LOG_ERR, 1, "%s %s  Error - select() call failed: %m.\n", 
     108                                        logpre, portstr); 
     109                                return(-1); 
    101110                        } 
    102                         logmsg(LOG_ERR, 1, "%s %s  Error - select() call failed: %s \n", 
    103                                 logpre, portstr, strerror(errno)); 
    104                         return(-1); 
    105111                case 0: 
    106112                        logmsg(LOG_DEBUG, 1, "%s %s  Unable to establish %s connection: %s.\n", 
    …… 
    113119                local_addr_len = 0; 
    114120                if (getsockname(proxy_sock_fd, (struct sockaddr *) &local_socket, (socklen_t *) &local_addr_len) != 0) { 
    115                         logmsg(LOG_ERR, 1, "%s %s  Error - Unable to get local address from %s socket: %s\n", 
    116                                 logpre, portstr, logact, strerror(errno)); 
     121                        logmsg(LOG_ERR, 1, "%s %s  Error - Unable to get local address from %s socket: %m.\n", 
     122                                logpre, portstr, logact); 
    117123                        return(-1); 
    118124                } 
    …… 
    134140                /* write read bytes to save_string at offset */ 
    135141                if (!(*save_string = (u_char *) realloc(*save_string, offset+(*bytes_read)))) { 
    136                         logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %s\n", strerror(errno)); 
     142                        logmsg(LOG_ERR, 1, "Error - Unable to allocate memory: %m.\n"); 
    137143                        close(from_fd); 
    138144                        close(to_fd); 

  • honeytrap/trunk/src/readconf.c

    r1334 r1355  
    147147 
    148148        /* initialilzation of variables */ 
    149         default_response      = NULL; /* initialize default response list */ 
     149        response_list         = NULL; /* initialize default response list */ 
    150150        pidfile_fd              = 0; 
    151151#ifdef USE_PCAP_MON 
    …… 
    238238 
    239239 
     240        /* install signal handlers */ 
     241        install_signal_handlers(); 
     242 
     243 
    240244        /* process remaining options now */ 
    241245        optind = 1; 
    …… 
    274278                        case 'u': 
    275279                                if ((pwd_entry = getpwnam(optarg)) == NULL) { 
    276                                         if (errno) fprintf(stderr, "  Invalid user: %s\n", strerror(errno)); 
     280                                        if (errno) fprintf(stderr, "  Invalid user: %m.\n"); 
    277281                                        else fprintf(stderr, "  User %s not found.\n", optarg); 
    278282                                        exit(EXIT_FAILURE); 
    …… 
    284288                        case 'g': 
    285289                                if ((grp_entry = getgrnam(optarg)) == NULL) { 
    286                                         if (errno) fprintf(stderr, "  Invalid group: %s\n", strerror(errno)); 
     290                                        if (errno) fprintf(stderr, "  Invalid group: %m.\n"); 
    287291                                        else fprintf(stderr, "  Group %s not found.\n", optarg); 
    288292                                        exit(EXIT_FAILURE); 
    …… 
    305309                } 
    306310        } 
     311 
    307312 
    308313#ifdef USE_PCAP_MON 
    …… 
    368373        /* open logfile */ 
    369374        if((logfile_fd = open(logfile_name, EXCL_FILE_RW, 0644)) == -1) { 
    370                 fprintf(stderr, "  Error - Unable to open logfile %s: %s.\n", logfile_name, strerror(errno)); 
     375                fprintf(stderr, "  Error - Unable to open logfile %s: %m.\n", logfile_name); 
    371376                exit(EXIT_FAILURE); 
    372377        } 
    …… 
    467472                else if (OPT_IS("user")) { 
    468473                        if ((pwd_entry = getpwnam(value)) == NULL) { 
    469                                 if (errno) fprintf(stderr, "  Error - Invalid user '%s': %s\n", value, strerror(errno)); 
     474                                if (errno) fprintf(stderr, "  Error - Invalid user '%s': %m.\n", value); 
    470475                                else fprintf(stderr, "  Error - User %s not found.\n", value); 
    471476                                exit(EXIT_FAILURE); 
    …… 
    476481                } else if (OPT_IS("group")) { 
    477482                        if ((grp_entry = getgrnam(value)) == NULL) { 
    478                                 if (errno) fprintf(stderr, "  Error - Invalid group '%s': %s\n", value, strerror(errno)); 
     483                                if (errno) fprintf(stderr, "  Error - Invalid group '%s': %m.\n", value); 
    479484                                else fprintf(stderr, "  Error - Group %s not found.\n", value); 
    480485                                exit(EXIT_FAILURE); 

  • honeytrap/trunk/src/response.c

    r1286 r1355  
    3636 
    3737void unload_default_responses(void) { 
    38         struct default_resp *cur_response; 
     38        def_resp *cur_response; 
    3939         
    40         while(default_response) { 
    41                 cur_response = default_response->next; 
    42                 free(default_response->response); 
    43                 free(default_response); 
    44                 default_response = cur_response; 
     40        while(response_list) { 
     41                cur_response = response_list->next; 
     42                free(response_list->response); 
     43                free(response_list); 
     44                response_list = cur_response; 
    4545        } 
    4646        return; 
    …… 
    5151        u_char buffer[100]; 
    5252        FILE* answer_file = NULL; 
    53         struct default_resp *last_response, *new_response; 
     53        def_resp *last_response, *new_response; 
    5454 
    5555        /* allocate memory for new response */ 
    56         if ((new_response = (struct default_resp *) malloc(sizeof(struct default_resp))) == NULL) { 
     56        if ((new_response = (def_resp *) malloc(sizeof(struct def_resp))) == NULL) { 
    5757                perror("  Error - Unable to allocate memory"); 
    5858                return(-1); 
    …… 
    6464                new_response->next      = NULL; 
    6565        } 
    66         if (!default_response) default_response = new_response; 
     66        if (!response_list) response_list = new_response; 
    6767        else {  
    6868                /* spool to end of the list and attach new response */ 
    69                 last_response = default_response; 
     69                last_response = response_list; 
    7070                while (last_response->next) last_response = last_response->next; 
    7171                last_response->next = new_response; 
    7272        } 
    73  
    7473 
    7574        /* read response */ 
    …… 
    147146 
    148147int send_default_response(int connection_fd, uint16_t port, uint16_t proto, u_char timeout) { 
    149         struct default_resp *cur_response; 
     148        def_resp *cur_response = NULL; 
    150149 
    151150        if ((proto != TCP) && (proto != UDP)) { 
    …… 
    157156         
    158157        /* advance through list to find response for port */ 
    159         cur_response = default_response; 
    160         while(cur_response && (cur_response->port != port) && (cur_response->proto != proto)) 
     158        cur_response = response_list; 
     159        while(cur_response && ((cur_response->port != port) || (cur_response->proto != proto))) 
    161160                cur_response = cur_response->next; 
    162161         

  • honeytrap/trunk/src/response.h

    r1117 r1355  
    2121#include <netinet/in.h> 
    2222 
    23 struct default_resp { 
     23typedef struct def_resp { 
    2424        uint16_t port; 
    2525        uint16_t proto; 
    2626        uint32_t size; 
    2727        u_char *response; 
    28         struct default_resp *next; 
    29 } *default_response; 
     28        struct def_resp *next; 
     29} def_resp; 
     30 
     31def_resp *response_list; 
    3032 
    3133