Exemplo n.º 1
0
// init_main - the second kernel thread used to create user_main kernel threads
static int
init_main(void *arg) {
    cprintf(" kernel_thread, pid = %d, name = %s\n", current->pid, get_proc_name(current));
	schedule();
    cprintf(" kernel_thread, pid = %d, name = %s , arg  %s \n", current->pid, get_proc_name(current), (const char *)arg);
	schedule();
    cprintf(" kernel_thread, pid = %d, name = %s ,  en.., Bye, Bye. :)\n",current->pid, get_proc_name(current));
    return 0;
}
void MessageBrokerStub::push(const char* queue_id, const void *msg, size_t size_txt) {

   Log::debug("MessageBrokerStub: triying to send msg of size %d to queue_id '%s'", size_txt, queue_id);

   if(size_txt+sizeof(long)>MAX_MSG_SIZE)
      throw MessageBrokerError("Message for %s too long size=%d, max_size=%d", queue_id, size_txt, MAX_MSG_SIZE);

   BrokerRequest request;
   BrokerResponse response;

   request.mtypebroker = BROKER_PUSH;

   strcpy(request.queue_id, queue_id);   
   request.size_txt = size_txt;
   memcpy(request.msg, msg, size_txt+sizeof(long));
   strcpy(request.sender_procname, get_proc_name().c_str() );
   
   try {
      MessageBrokerServer::sendall(sock, (char*)&request, sizeof(BrokerRequest));
      MessageBrokerServer::receiveall(sock, (char*)&response, sizeof(BrokerResponse));
   } catch(OSError & error) {
      throw MessageBrokerError("Network error, cause: %s", error.what());
   }

   if(response.mtypebroker == BROKER_ERROR)
      throw MessageBrokerError("Error al hacer push en la cola en el broker remoto");
}
Exemplo n.º 3
0
log_conf::log_conf()
{
    file_max_size = DEFAULT_LOG_MAX_SIZE;
    strcpy(log_path, "logs");
    get_proc_name(prefix_file_name, sizeof(prefix_file_name));
    type = LOGDEBUG;
}
Exemplo n.º 4
0
// init_main - the second kernel thread used to create user_main kernel threads
static int
init_main(void *arg) {
    cprintf("this initproc, pid = %d, name = \"%s\"\n", current->pid, get_proc_name(current));
    cprintf("To U: \"%s\".\n", (const char *)arg);
    cprintf("To U: \"en.., Bye, Bye. :)\"\n");
    return 0;
}
ssize_t MessageBrokerStub::pull(const char* queue_id, void *msg, size_t max_size_txt, long type) {

   Log::debug("MessageBrokerStub: triying to pull of the queue_id '%s' with type %d", queue_id, type);

   BrokerRequest request;
   BrokerResponse response;

   request.mtypebroker = BROKER_PULL;
   strcpy(request.queue_id, queue_id);   
   request.max_size_txt = max_size_txt;
   request.type = type;
   strcpy(request.sender_procname, get_proc_name().c_str() );

   if(max_size_txt+sizeof(long)>MAX_MSG_SIZE)
      throw MessageBrokerError("Message for %s too long size=%d, max_size=%d", queue_id, max_size_txt, MAX_MSG_SIZE);

   try {
      MessageBrokerServer::sendall(sock, (char*)&request, sizeof(BrokerRequest));
      MessageBrokerServer::receiveall(sock, (char*)&response, sizeof(BrokerResponse));
      Log::debug("MessageBrokerStub: Receive from queue_id %s", queue_id);
   } catch(OSError & error) {
      throw MessageBrokerError("Network error, cause: %s", error.what());
   }

   if(response.mtypebroker == BROKER_ERROR) {
      throw MessageBrokerError("Error al hacer push en la cola en el broker remoto");
   } else {
      memcpy(msg, response.msg, max_size_txt+sizeof(long));
   }
   return response.msg_size;
}
Exemplo n.º 6
0
void print_usage(struct usage *help_usage)
{
    struct usage *use    = help_usage;
    int opt_name_max_len = 0;
    int opt_name_len     = 0;
    int opt_usg_len      = 0;
    int usg_cnt          = 0;
    int cpy_cnt          = 0;
    char *buf            = NULL;
    //char buf[usage_line_len + 1] = {0};
    char c = ' ';

    if (!use) return;
    buf = (char *)malloc(usage_line_len + 1);
    if (!buf) return;
    
    printf("Usage: %s [Options] [Parameters]\n", get_proc_name());
    printf("The Options arg:\n");

    for (use = help_usage; use->opt_name != NULL; use++) {
        opt_name_len = strlen(use->opt_name);
        if (opt_name_len > opt_name_max_len) opt_name_max_len = opt_name_len;
    }

    for (use = help_usage; use->opt_name != NULL; use++) {
        usg_cnt = 0;
        opt_usg_len = strlen(use->opt_usage);
        opt_name_len = strlen(use->opt_name);
        if (opt_usg_len > usage_line_len) {
            memcpy(buf, use->opt_usage + usg_cnt, usage_line_len);
            usg_cnt += usage_line_len;
            if (isalpha((use->opt_usage + usg_cnt - 1)[0]))
                c = '-';
            printf("  %s%*c%s%c\n", use->opt_name, opt_name_max_len + 2 - opt_name_len, ' ', buf, c);

            while (usg_cnt < opt_usg_len) {
                cpy_cnt = usg_cnt + usage_line_len < opt_usg_len ? usage_line_len - 1 : (opt_usg_len - usg_cnt);
                memcpy(buf, use->opt_usage + usg_cnt, cpy_cnt);
                buf[cpy_cnt] = '\0';
                usg_cnt += cpy_cnt;
                if (usg_cnt < opt_usg_len) {
                    if (isalpha((use->opt_usage + usg_cnt - 1)[0]))
                        c = '-';
                } else {
                    c = ' ';
                }
                printf("  %*c%s%c\n", opt_name_max_len + 2, ' ', buf, c);

            }
        } else {
            printf("  %s%*c%s\n", use->opt_name, opt_name_max_len + 2 - opt_name_len, ' ', use->opt_usage);
        }
        memset(buf, 0, sizeof(usage_line_len + 1));
    }

    if (buf) free(buf);
}
Exemplo n.º 7
0
PROTECTED int
unw_get_proc_name (unw_cursor_t *cursor, char *buf, size_t buf_len,
		   unw_word_t *offp)
{
  struct cursor *c = (struct cursor *) cursor;

  return get_proc_name (tdep_get_as (c), tdep_get_ip (c), buf, buf_len, offp,
			tdep_get_as_arg (c));
}
Exemplo n.º 8
0
static void __log_init(void)
{
    int type = _log_type;
    const char *ident = _log_ident;
    if (_is_log_init) {
        return;
    }
    log_check_env();
#ifdef LOG_VERBOSE_ENABLE
    UPDATE_LOG_PREFIX(_log_prefix, LOG_VERBOSE_BIT);
#endif
    UPDATE_LOG_PREFIX(_log_prefix, LOG_FUNCLINE_BIT);

#ifdef LOG_IO_OPS
    _log_use_io = 1;
#endif
    if (_log_use_io) {
        _log_handle = &log_io_ops;
    } else {
        _log_handle = &log_fio_ops;
    }

    if (CHECK_LOG_PREFIX(_log_prefix, LOG_VERBOSE_BIT)) {
        memset(_proc_name, 0, sizeof(_proc_name));
        char *proc = get_proc_name();
        if (proc) {
            memset(_log_name, 0, sizeof(_log_name));
            strncpy(_proc_name, proc, strlen(proc));
            free(proc);
        }
    }
    if (type == 0) {
    } else {
        _log_output = type;
    }
    switch (_log_output) {
    case LOG_STDERR:
        _log_driver = &log_stderr_driver;
        break;
    case LOG_FILE:
        _log_driver = &log_file_driver;
        break;
    case LOG_RSYSLOG:
        _log_driver = &log_rsys_driver;
        break;
    default:
        fprintf(stderr, "unsupport log type!\n");
        break;
    }
    _log_driver->init(ident);
    _is_log_init = 1;
    pthread_mutex_init(&_log_mutex, NULL);
    return;
}
Exemplo n.º 9
0
int main(int argc, char** argv, char** envp)
{
    pids.resize(100);
    auto size = get_pidlist(pids);

    while (pids.size()/sizeof(int) <= size)
    {
        pids.resize(pids.size() * 2);
        size = get_pidlist(pids);
    }

    pids.resize(size / sizeof(int));

    for (auto x : pids)
    {
        std::string name = get_proc_name(x);
        if( name != "Unable to open process. Skipping...")
            procList[x] = get_proc_name(x);
    }

    print_procs(procList);

	return 0;
}
Exemplo n.º 10
0
string * sah_data_process::get_send_head()
{
    string * str = new string;
    http_res_head_para & res_head = _base_process->get_res_head_para();
    
    char proc_name[SIZE_LEN_256] = {'\0'};
    get_proc_name(proc_name, sizeof(proc_name));

    res_head._headers.insert(make_pair("Date", SecToHttpTime(time(NULL))));
    res_head._headers.insert(make_pair("Server", proc_name));
    res_head._headers.insert(make_pair("Connection", "keep-alive"));
    res_head._content_length = _body.length();
    _base_process->gen_send_head(str);

    LOG_DEBUG("%s", str->c_str());
    return str;
}
void MessageBrokerStub::create_queue(const char* queue_id) {

   BrokerRequest request;
   BrokerResponse response;

   request.mtypebroker = BROKER_CREATE;
   strcpy(request.queue_id, queue_id);
   strcpy(request.sender_procname, get_proc_name().c_str() );

   try {
      MessageBrokerServer::sendall(sock, (char*)&request, sizeof(BrokerRequest));
      MessageBrokerServer::receiveall(sock, (char*)&response, sizeof(BrokerResponse));
   } catch(OSError & error) {
      throw MessageBrokerError("Network error, cause: %s", error.what());
   }

   if(response.mtypebroker == BROKER_ERROR)
      throw MessageBrokerError("Error al crear la cola en el broker remoto");
}
Exemplo n.º 12
0
void rg_error_init(int _reboot_on_exit, int _reboot_on_panic,
    int strace, char *process, rg_error_level_t console_level,
    int (*_main_addr)(int, char *[]), const char *_main_name)
{
    if (inited)
	rg_error(LEXIT, "rg_error_init: already inited");
    inited = 1;
    if (strace)
	strace_init();
    if (process)
    {
	strncpy(proc_name, process, MAX_PROC_NAME);
	proc_name[MAX_PROC_NAME-1] = 0;
    }
    else
	strcpy(proc_name, get_proc_name());
    rg_error_console_level = console_level;
    main_addr = _main_addr;
    main_name = _main_name;
    reboot_on_exit = _reboot_on_exit;
    reboot_on_panic = _reboot_on_panic;
}
Exemplo n.º 13
0
Arquivo: proc.c Projeto: antontest/c
/**
 * @brief check_proc_unique 
 *
 * @param name [in] process name
 *
 * @return 1, if process unique; otherwise return 0
 */
int check_proc_unique(const char *name)
{
    FILE *fp = NULL;
    char cmd[256] = {0};
    char buf[518] = {0};
    int task_cnt = 0;

    name = get_proc_name(name);
    sprintf(cmd, "ps -a | grep %s | grep -v grep | \
            awk '{ print $1}'", name);
    if ((fp = popen(cmd, "r")) == NULL) return -1;
    while (fgets(buf, sizeof(buf), fp) != NULL)
    {
        if (strlen(buf) && atoi(buf) > 0)
            task_cnt++;
        if (task_cnt > 1) break;
    }

    if (fp != NULL) pclose(fp);
    if (task_cnt > 1) return 0;
    return 1;
}
void MessageBrokerStub::destroy_queue(const char* queue_id) {

   Log::debug("MessageBrokerStub: triying to destroy the queue_id '%s'", queue_id);

   BrokerRequest request;
   BrokerResponse response;

   request.mtypebroker = BROKER_DESTROY;
   strcpy(request.queue_id, queue_id);   
   strcpy(request.sender_procname, get_proc_name().c_str() );

   try {
      MessageBrokerServer::sendall(sock, (char*)&request, sizeof(BrokerRequest));
      MessageBrokerServer::receiveall(sock, (char*)&response, sizeof(BrokerResponse));
      Log::debug("MessageBrokerStub: queue destroy ok '%s'", queue_id);
   } catch(std::exception & error) {
      throw MessageBrokerError("Network error, cause: %s", error.what());
   }

   if(response.mtypebroker == BROKER_ERROR)
      throw MessageBrokerError("Error al destruir la cola en el broker remoto");
}
Exemplo n.º 15
0
int
main(int argc, char **argv)
{
    int32_t arg_id;
    int     fd, clonefd = -1;
    int     i, j, eoff, off, ret;

    kfs_event_arg_t *kea;
    struct           fsevent_clone_args fca;
    char             buffer[FSEVENT_BUFSIZ];
    struct passwd   *p;
    struct group    *g;
    mode_t           va_mode;
    u_int32_t        va_type;
    u_int32_t        is_fse_arg_vnode = 0;
    char             fileModeString[11 + 1];
    int8_t           event_list[] = { // action to take for each event
                         FSE_REPORT,  // FSE_CREATE_FILE,
                         FSE_REPORT,  // FSE_DELETE,
                         FSE_REPORT,  // FSE_STAT_CHANGED,
                         FSE_REPORT,  // FSE_RENAME,
                         FSE_REPORT,  // FSE_CONTENT_MODIFIED,
                         FSE_REPORT,  // FSE_EXCHANGE,
                         FSE_REPORT,  // FSE_FINDER_INFO_CHANGED,
                         FSE_REPORT,  // FSE_CREATE_DIR,
                         FSE_REPORT,  // FSE_CHOWN,
                         FSE_REPORT,  // FSE_XATTR_MODIFIED,
                         FSE_REPORT,  // FSE_XATTR_REMOVED,
                     };

    if (argc != 1) {
        fprintf(stderr, "%s (%s)\n", PROGNAME, PROGVERS);
        fprintf(stderr, "File system change logger for Mac OS X. Usage:\n");
        fprintf(stderr, "\n\t%s\n\n", PROGNAME);
        fprintf(stderr, "%s does not take any arguments. "
                        "It must be run as root.\n\n", PROGNAME);
        printf("Please report bugs using the following contact information:\n"
           "<URL:http://www.osxbook.com/software/bugs/>\n");

        exit(1);
        exit(1);
    }

    if (geteuid() != 0) {
        fprintf(stderr, "You must be root to run %s. Try again using 'sudo'.\n",
                PROGNAME);
        exit(1);
    }

    setbuf(stdout, NULL);

    if ((fd = open(DEV_FSEVENTS, O_RDONLY)) < 0) {
        perror("open");
        exit(1);
    }

    fca.event_list = (int8_t *)event_list;
    fca.num_events = sizeof(event_list)/sizeof(int8_t);
    fca.event_queue_depth = EVENT_QUEUE_SIZE;
    fca.fd = &clonefd; 
    if ((ret = ioctl(fd, FSEVENTS_CLONE, (char *)&fca)) < 0) {
        perror("ioctl");
        close(fd);
        exit(1);
    }

    close(fd);

    if ((ret = ioctl(clonefd, FSEVENTS_WANT_EXTENDED_INFO, NULL)) < 0) {
        perror("ioctl");
        close(clonefd);
        exit(1);
    }
   // char string2[20]="red dwarf";
   // char string1[20]="";
   //  strcpy(string1, string2);
    char lastpath[300] = "blank";
    char currentpath[300];
    while (1) { // event processing loop
        ret = read(clonefd, buffer, FSEVENT_BUFSIZ);

        off = 0;

        while (off < ret) { // process one or more events received

            struct kfs_event *kfse = (struct kfs_event *)((char *)buffer + off);

            off += sizeof(int32_t) + sizeof(pid_t); // type + pid

            if (kfse->type == FSE_EVENTS_DROPPED) { // special event
                fprintf(stderr, "  %-14s = %s\n", "type", "EVENTS DROPPED");
                exit(1);
            }

            int32_t atype = kfse->type & FSE_TYPE_MASK;
            uint32_t aflags = FSE_GET_FLAGS(kfse->type);

            if ((atype < FSE_MAX_EVENTS) && (atype >= -1)) {

                if (aflags & FSE_COMBINED_EVENTS) {
                    fprintf(stderr,"%s", ", combined events");
                    exit(1);
                }
                if (aflags & FSE_CONTAINS_DROPPED_EVENTS) {
                    fprintf(stderr,"%s", ", contains dropped events");
                    exit(1);
                }
            } else { // should never happen
                printf("This may be a program bug (type = %d).\n", atype);
                exit(1);
            }

            kea = kfse->args; 
            i = 0;

            while (off < ret) {  // process arguments

                i++;

                if (kea->type == FSE_ARG_DONE) { // no more arguments
                    // printf("    %s (%#x)\n", "FSE_ARG_DONE", kea->type);
                    off += sizeof(u_int16_t);
                    break;
                }

                eoff = sizeof(kea->type) + sizeof(kea->len) + kea->len;
                off += eoff;

                arg_id = (kea->type > FSE_MAX_ARGS) ? 0 : kea->type;
                // printf("    %-16s%4hd  ", kfseArgNames[arg_id], kea->len);
                
                
                // switch kfseNames[atype]
                // printf("%d ", kfse->pid);
                
                if (kea->type == FSE_ARG_STRING) { // handle based on argument type
                    strcpy (currentpath,(char *)&(kea->data.str));
                    //  OR atype == FSE_RENAME
                    // strcmp(currentpath, lastpath) != 0
                    if (    atype == FSE_RENAME || 
                            atype == FSE_CREATE_FILE || 
                            atype == FSE_CREATE_DIR || 
                            strcmp(currentpath, lastpath) != 0) {
                        printf("%d\t%s\t%s\t%s\n", kfse->pid, get_proc_name(kfse->pid), kfseNames[atype], currentpath);
                    }
                    strcpy (lastpath,currentpath);
                }

                kea = (kfs_event_arg_t *)((char *)kea + eoff); // next
            } // for each argument
        } // for each event
    } // forever

    close(clonefd);

    exit(0);
}
Exemplo n.º 16
0
int
main(int argc, char **argv)
{
    int32_t arg_id;
    int     fd, clonefd = -1;
    int     i, j, eoff, off, ret;
    FILE*   onf;
    char    msg[MAX_SEND];
    int     c;
    int     mlen          = 0;
    int     udp           = 0;
    int     det           = 0;
    char    fname[MAX_FILENAME] = "";
    char    raddr[MAX_IP] = "127.0.0.1";
    int     rport         = 12345;

    kfs_event_arg_t *kea;
    struct           fsevent_clone_args fca;
    char             buffer[FSEVENT_BUFSIZ];
    struct passwd   *p;
    struct group    *g;
    mode_t           va_mode;
    u_int32_t        va_type;
    u_int32_t        is_fse_arg_vnode = 0;
    char             fileModeString[11 + 1];
    int8_t           event_list[] = { // action to take for each event
                         FSE_REPORT,  // FSE_CREATE_FILE,
                         FSE_REPORT,  // FSE_DELETE,
                         FSE_REPORT,  // FSE_STAT_CHANGED,
                         FSE_REPORT,  // FSE_RENAME,
                         FSE_REPORT,  // FSE_CONTENT_MODIFIED,
                         FSE_REPORT,  // FSE_EXCHANGE,
                         FSE_REPORT,  // FSE_FINDER_INFO_CHANGED,
                         FSE_REPORT,  // FSE_CREATE_DIR,
                         FSE_REPORT,  // FSE_CHOWN,
                         FSE_REPORT,  // FSE_XATTR_MODIFIED,
                         FSE_REPORT,  // FSE_XATTR_REMOVED,
                     };

    // Print usage if not root
    if (geteuid() != 0){
        usage();
        exit(1);
    }

    onf = stdout;
    opterr = 0;
    while ((c = getopt (argc, argv, "huf:s:p:")) != -1)
        switch (c){
            case 'f':
                strncpy(fname,optarg,MAX_FILENAME - 1);
                    
                onf = fopen(fname,"w");
                if (onf == NULL){
                    fprintf(stderr, "Cannot open output file %s.\n\n",optarg);
                    usage();
                    exit(1);
                }
                break;
            case 'u':
                udp = 1;
                break;
            case 's':
                strncpy(raddr,optarg,MAX_IP);
                break;
            case 'p':
                rport = atoi( optarg );
                break;
            case 'h':
            case '?':
                if (optopt == 'f'){
                    fprintf(stderr, "Output filename required.\n");
                    usage();
                    exit(1);
                }
                usage();
                exit(1);
        }

    setbuf(onf, NULL);

    //Set UDP Socket
    set_dest(raddr, rport);
    set_sock();

    if ((fd = open(DEV_FSEVENTS, O_RDONLY)) < 0) {
        perror("open");
        exit(1);
    }

    fca.event_list = (int8_t *)event_list;
    fca.num_events = sizeof(event_list)/sizeof(int8_t);
    fca.event_queue_depth = EVENT_QUEUE_SIZE;
    fca.fd = &clonefd; 
    if ((ret = ioctl(fd, FSEVENTS_CLONE, (char *)&fca)) < 0) {
        perror("ioctl");
        close(fd);
        exit(1);
    }

    close(fd);

    //YAML comments lines start with '#'. Use this for debug and status statements
    snprintf(msg, MAX_DATA,"#fsevents device cloned (fd %d)\n#fslogger ready\n",clonefd);
    if (udp){
        send_packet(msg, strlen(msg));
    } else {
        fprintf(onf,"%s",msg);
        // Since we use setbuf this might not be necessary. Let's do it anyway.
        fflush(onf);
    }

    if ((ret = ioctl(clonefd, FSEVENTS_WANT_EXTENDED_INFO, NULL)) < 0) {
        perror("ioctl");
        close(clonefd);
        exit(1);
    }

    while (1) { // event processing loop

        if ((ret = read(clonefd, buffer, FSEVENT_BUFSIZ)) > 0){
            snprintf(msg, MAX_DATA, "# => received %d bytes\n", ret);
            if (udp){
                send_packet(msg, strlen(msg));
            } else {
                fprintf(onf,"%s", msg);
                fflush(onf);
            }
        }

        off = 0;

        while (off < ret) { // process one or more events received
        
            // Start message over
            mlen = 0;

            struct kfs_event *kfse = (struct kfs_event *)((char *)buffer + off);

            off += sizeof(int32_t) + sizeof(pid_t); // type + pid

            //Use snprintf for formatting to permit concantenting the message together
            mlen += snprintf(msg + mlen, MAX_DATA, "---\n");

            if (kfse->type == FSE_EVENTS_DROPPED) { // special event
                mlen += snprintf(msg + mlen, MAX_DATA, "Event:\n");
                mlen += snprintf(msg + mlen, MAX_DATA, " %s: %s\n", "type", "EVENTS_DROPPED");
                mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d\n", "pid", kfse->pid);
                // Special event with continue. So send data then restart loop
                if (udp){
                    send_packet(msg, strlen(msg));
                } else {
                    fprintf(onf,"%s", msg);
                    fflush(onf);
                }

                off += sizeof(u_int16_t); // FSE_ARG_DONE: sizeof(type)
                continue;
            }

            int32_t atype = kfse->type & FSE_TYPE_MASK;
            uint32_t aflags = FSE_GET_FLAGS(kfse->type);

            if ((atype < FSE_MAX_EVENTS) && (atype >= -1)) {
                mlen += snprintf(msg + mlen, MAX_DATA, "Event:\n");
                mlen += snprintf(msg + mlen, MAX_DATA, " %s: %s", "type", kfseNames[atype]);
                if (aflags & FSE_COMBINED_EVENTS) {
                    mlen += snprintf(msg + mlen, MAX_DATA,"%s", ", combined events");
                }
                if (aflags & FSE_CONTAINS_DROPPED_EVENTS) {
                    mlen += snprintf(msg + mlen, MAX_DATA, "%s", ", contains dropped events");
                }
                mlen += snprintf(msg + mlen,MAX_DATA, "%s","\n");


            } else { // should never happen
                mlen += snprintf(msg + mlen, MAX_DATA, "# This may be a program bug (type = %d).\n", atype);
                // Special event with exit. So send data
                if (udp){
                    send_packet(msg, strlen(msg));
                } else {
                    fprintf(onf,"%s", msg);
                    fflush(onf);
                }
                exit(1);
            }

            mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d\n", "pid", kfse->pid);
            mlen += snprintf(msg + mlen, MAX_DATA, " %s: %s\n", "pname", get_proc_name(kfse->pid));

            mlen += snprintf(msg + mlen, MAX_DATA, "%s", "Details:\n");

            kea = kfse->args; 
            i = 0;

            //while ((off < ret) && (i <= FSE_MAX_ARGS)) { // process arguments
            while (off < ret) {

                i++;

                if (kea->type == FSE_ARG_DONE) { // no more arguments
                    mlen += snprintf(msg + mlen, MAX_DATA, " %s:\n", "FSE_ARG_DONE");
                    // Added Length for FSE_ARG_DONE to be consistent with other values
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %d\n", "len", 0);
                    // Added Type for FSE_ARG_DONE to be consistent with other values
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %d\n", "type", kea->type);

                    //This should be the only time to send data for a YAML doc which is a full FSEVENT
                    if (udp){
                        send_packet(msg, strlen(msg));
                    } else {
                        fprintf(onf,"%s", msg);
                        fflush(onf);
                    }
                    det = 0;
                    off += sizeof(u_int16_t);
                    break;
                }

                eoff = sizeof(kea->type) + sizeof(kea->len) + kea->len;
                off += eoff;

                arg_id = (kea->type > FSE_MAX_ARGS) ? 0 : kea->type;
                // Do no put detail marker on timestamp
                if (arg_id == 5){
                    mlen += snprintf(msg + mlen, MAX_DATA, " %s:\n", kfseArgNames[arg_id]);
                } else {
                    mlen += snprintf(msg + mlen, MAX_DATA, " %s_%d:\n", kfseArgNames[arg_id],det);
                }
                mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %d\n", "len", kea->len);

                switch (kea->type) { // handle based on argument type

                case FSE_ARG_VNODE:  // a vnode (string) pointer
                    is_fse_arg_vnode = 1;
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %s\n", "path", (char *)&(kea->data.vp));
                    break;

                case FSE_ARG_STRING: // a string pointer
                    // Added double quotes to protect strings with ":"s 
                    // Actually, to handle "\" it needs to be a single quote
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: \'%s\'\n", "string", (char *)&(kea->data.str)-4);
                    break;

                case FSE_ARG_INT32:
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %d\n", "int32", kea->data.int32);
                    break;

                case FSE_ARG_RAW: // a void pointer
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: ", "ptr");
                    for (j = 0; j < kea->len; j++)
                        mlen += snprintf(msg + mlen, MAX_DATA, "%02x ", ((char *)kea->data.ptr)[j]);
                    mlen += snprintf(msg + mlen, MAX_DATA, "%s", "\n");
                    break;

                case FSE_ARG_INO: // an inode number
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %d\n", "ino", (int)kea->data.ino);
                    break;

                case FSE_ARG_UID: // a user ID
                    p = getpwuid(kea->data.uid);
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %d (%s)\n", "uid", kea->data.uid, (p) ? p->pw_name : "?");
                    break;

                case FSE_ARG_DEV: // a file system ID or a device number
                    if (is_fse_arg_vnode) {
                        mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %#08x\n", "fsid", kea->data.dev);
                        is_fse_arg_vnode = 0;
                    } else {
                        mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %#08x (major %u, minor %u)\n", "dev", kea->data.dev, major(kea->data.dev), minor(kea->data.dev));
                    }
                    break;

                case FSE_ARG_MODE: // a combination of file mode and file type
                    va_mode = (kea->data.mode & 0x0000ffff);
                    va_type = (kea->data.mode & 0xfffff000);
                    strmode(va_mode, fileModeString);
                    va_type = iftovt_tab[(va_type & S_IFMT) >> 12];
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %s (%#08x, vnode type %s)", "mode", fileModeString, kea->data.mode, (va_type < VTYPE_MAX) ?  vtypeNames[va_type] : "?");
                    if (kea->data.mode & FSE_MODE_HLINK) {
                        mlen += snprintf(msg + mlen, MAX_DATA, "%s", ", hard link");
                    }
                    if (kea->data.mode & FSE_MODE_LAST_HLINK) {
                        mlen += snprintf(msg + mlen, MAX_DATA, "%s", ", link count zero now");
                    }
                    mlen += snprintf(msg + mlen, MAX_DATA, "%s", "\n");
                    break;

                case FSE_ARG_GID: // a group ID
                    g = getgrgid(kea->data.gid);
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %d (%s)\n", "gid", kea->data.gid, (g) ? g->gr_name : "?");
                    // This is usually the last value before everything repeats. Inc det
                    det += 1;
                    break;

                case FSE_ARG_INT64: // timestamp
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s: %llu\n", "tstamp", kea->data.timestamp);
                    break;

                default:
                    mlen += snprintf(msg + mlen, MAX_DATA, "   %s = ?\n", "unknown");
                    break;
                }

                kea = (kfs_event_arg_t *)((char *)kea + eoff); // next
            } // for each argument
        } // for each event
    } // forever

    close(clonefd);

    // Only close output file if it is not stdout
    if (argc == 2) {
        fclose(onf);
    }

    exit(0);
}
/*
 * enumerate all modules for process
 * pid: process id
 * lsc: load sample count
 */
static void enum_modules_for_process(pid_t pid, unsigned long long lsc, const char * proc_name)
{
	bool find = false;
	char *filename;
	unsigned long name_offset;
	unsigned int options;
	struct task_struct *task;
	struct vm_area_struct *mmap;
	struct mm_struct *mm;
	char * name = NULL;
	char * buffer = NULL;

	task = px_find_task_by_pid(pid);

	if (task == NULL)
		goto ret;

	name = kzalloc(PATH_MAX, GFP_ATOMIC);

	if (name == NULL)
		goto ret;

	buffer = kzalloc(PATH_MAX, GFP_ATOMIC);

	if (buffer == NULL)
		goto ret;

	mm = get_task_mm(task);
	if (mm != NULL)
	{
		down_read(&mm->mmap_sem);

		for (mmap = mm->mmap; mmap; mmap = mmap->vm_next)
		{
			if (is_valid_module(mmap))
			{
				memset(name, 0, (PATH_MAX) * sizeof(char));
				filename = px_d_path(mmap->vm_file, name, PATH_MAX);

				if (filename != NULL)
				{
					options = 0;

					if (find == false)
					{
						options |= MODULE_FLAG_1ST;
						find = true;

						if (proc_name != NULL)
						{
							/* for the first module (the executable image), if the process name is specified, use the specified one */
							strcpy(buffer, proc_name);
						}
						else
						{
							/*
							 * for the first module (the executable image), we need to get the process name again
							 * because it may be modified by changing the argv[0]
							 */
							if (get_proc_name(task, buffer) == 0)
							{
								/* failed to get the process name, use the orignal module name */
								strcpy(buffer, filename);
							}
						}

						/* save the orignal process name for checking if it will be updated later */
						notify_new_loaded_process(task, buffer);
					}
					else
					{
						memset(buffer, 0, sizeof(PATH_MAX));
						strcpy(buffer, filename);
					}

					name_offset = get_filename_offset(buffer);

					module_load_notif(buffer, name_offset, pid,
						              mmap->vm_start, mmap->vm_end - mmap->vm_start,
						              options, lsc);
				}
			}
		}

		up_read(&mm->mmap_sem);
		mmput(mm);
	}


	if (find == false)
	{
		module_load_notif(task->comm, 0, pid,
				  LINUX_APP_BASE_LOW, 0,//mmap->vm_end - mmap->vm_start,
				  MODULE_FLAG_1ST, lsc);
	}

ret:
	if (name != NULL)
		kfree(name);

	if (buffer != NULL)
		kfree(buffer);

	return;
}
Exemplo n.º 18
0
CLIP_DLLEXPORT int
_clip_load(ClipMachine * mp, const char *name, struct Coll *names, ClipVar * resp)
{
	ClipFile *file = 0;
	int r = 0;
	ClipBlock b;
	ClipCodeVar c;
	long hash;
	char *e = strrchr(name, '.');
	char *s = strrchr(name, '/');

	c.u.block = &b;
	if (e && (!s || s < e))
	{
		if (!strcmp(e, ".po") || !strcmp(e, ".pa"))
		{
			file = NEW(ClipFile);
			r = load_pobj(mp, file, name, 0);
		}
		else if (!strcasecmp(e, DLLREALSUFF))
		{
			r = load_dll(mp, name, names, resp);
			return r;
		}
		else
		{
			_clip_trap_printf(mp, __FILE__, __LINE__, "unknown file type: '%s'", name);
			return _clip_call_errblock(mp, 1);
		}
	}
	else
	{
		char path[256];

		snprintf(path, sizeof(path), "%s.po", name);
		if (!access(path, R_OK))
		{
			file = NEW(ClipFile);
			r = load_pobj(mp, file, path, 0);
		}
		else
		{
			snprintf(path, sizeof(path), "%s.pa", name);
			if (!access(path, R_OK))
			{
				file = NEW(ClipFile);
				r = load_pobj(mp, file, path, 0);
			}
			else
			{
				snprintf(path, sizeof(path), "%s%s", name, DLLREALSUFF);
				if (!access(path, R_OK))
				{
					r = load_dll(mp, path, names, resp);
					return r;
				}
				else
				{
					_clip_trap_printf(mp, __FILE__, __LINE__, "cannot load file: '%s'", name);
					return _clip_call_errblock(mp, 1);
				}
			}
		}
	}

	if (r)
		return r;

	++file->refCount;

	for (r = _clip_first_File(file, &c, &hash); r; r = _clip_next_File(file, &c, &hash))
	{
		if (c.t.type == CCODE_t)
		{
			if (resp)
			{
				ClipVar *vp;

				vp = NEW(ClipVar);

				CLEAR_CLIPVAR(resp);
				resp->t.flags = F_MPTR;
				resp->t.type = CCODE_t;
				resp->p.vp = vp;

				vp->t.count = 1;
				vp->t.type = CCODE_t;
				vp->t.flags = F_NONE;
				vp->c.u.func = c.u.func;
				++file->refCount;
				break;
			}
			else
			{
				if (_clip_register_hash(mp, c.u.func, hash))
					++file->refCount;
			}
		}
		else if (c.t.type == PCODE_t)
		{
			if (resp)
			{
				ClipVar *vp;
				ClipBlock *bp;

				vp = NEW(ClipVar);
				bp = NEW(ClipBlock);

				CLEAR_CLIPVAR(resp);
				resp->t.flags = F_MPTR;
				resp->t.type = PCODE_t;
				resp->p.vp = vp;

				vp->t.count = 1;
				vp->t.type = PCODE_t;
				vp->t.flags = F_NONE;
				*bp = *c.u.block;
				vp->c.u.block = bp;
				++file->refCount;
				break;
			}
			else
			{
				if (_clip_register_block(mp, *c.u.block, hash))
				{
					char *name;

					if (names)
					{
						name = get_proc_name(&c);
						append_Coll(names, strdup(name));
					}

					++file->refCount;
				}
			}
		}
	}

	_clip_load_inits(mp, file);

	delete_ClipFile(mp, file);

	return 0;
}
Exemplo n.º 19
0
static bool fm_loop (FileMonitor *fm, FileMonitorCallback cb) {
	FileMonitorEvent ev = {0};
	uint8_t buf[FM_BUFSIZE] = {0};
	int arg_len, rc, buf_idx = 0, buf_end = -1;

	if (sizeof (FMEventStruct) != 12) {
		eprintf ("Invalid FMEventStruct, check your compiler\n");
		return false;
	}

	for (; fm->running; ) {
		int rewind = 0;
		if (buf_idx == buf_end) {
			buf_idx = 0;
		} else if (buf_idx > 0) {
			if (buf_idx > buf_end) {
				eprintf ("Overflow detected and corrected (%d, %d)\n", buf_idx, buf_end);
				buf_idx = 0;
			} else {
				memmove (buf, buf + buf_idx, (buf_end - buf_idx));
				rewind = buf_idx = (buf_end - buf_idx);
			}
		}
		if (buf_idx > FM_BUFSIZE) {
			eprintf ("Warning: Some data is lost in fsevents data read (%d, %d)\n", buf_idx, FM_BUFSIZE);
			buf_idx = 0;
		}
		memset (buf + buf_idx, 0x00, FM_BUFSIZE - buf_idx);
		rc = read (fm->fd, buf + buf_idx, FM_BUFSIZE - buf_idx);
		// hexdump (buf+buf_idx, rc, 0); //arg_len + 2, 0);
		if (rc < 1) {
			if (errno != EINTR) {
				perror ("read");
			}
			return false;
		}
		buf_idx = 0;
		buf_end = buf_idx + rc;

		if (buf_end >= sizeof (buf))
			buf_end = sizeof (buf);
		while (buf_idx + 1 < buf_end) {
			// hexdump (buf+buf_idx, sizeof (FMEventStruct) + 32, 0);
			FMEventStruct *fme = (FMEventStruct*) (buf + buf_idx);
			/* initialize on first set */
			if (ev.type == -1) {
				ev.type = fme->type;
				ev.pid = fme->val.u32;
				ev.ppid = 0;
				ev.proc = get_proc_name (ev.pid, &ev.ppid);
				ev.file = (const char *)buf + buf_idx + sizeof (FMEventStruct);
			}
			/* parse data packet */
			arg_len = parse_event (&ev, fme);
			if (arg_len == -1) {
				if (ev.pid && ev.type != -1 && cb) {
					cb (fm, &ev);
				}
				fsevent_free (&ev);
				arg_len = 2;
			} else if (arg_len < 1) {
				arg_len = sizeof (FMEventStruct);
			} else if (arg_len > (buf_end - buf_idx)) {
#if WIP
				int i;
				bool found = false;
				for (i = buf_idx + 1; i + sizeof (FMEventStruct) < buf_end; i++) {
					if (!memcmp ("\x00\x00\xd4\x8f", buf +i, 4)) {
						found = true;
						break;
					}
				}
				if (found) {
					arg_len = i - buf_idx;
					eprintf ("FCU %d\n", arg_len);
				} else {
					arg_len = sizeof (FMEventStruct) + 2;
					eprintf ("Invalid length in fsevents data packet (%d, %d)\n",
							arg_len, buf_end - buf_idx);
					//arg_len += 12;
					// hexdump (buf + buf_idx, buf_end - buf_idx, 0); //arg_len + 2, 0);
				}
#else
				arg_len = sizeof (FMEventStruct) + 2;
				eprintf ("Invalid length in fsevents data packet (%d, %d)\n",
						arg_len, buf_end - buf_idx);
#endif
			}
			buf_idx += arg_len;
		}
	}
	return true;
}
Exemplo n.º 20
0
CLIP_DLLEXPORT int
_clip_load(ClipMachine * ClipMachineMemory, const char *name, struct Coll *names, ClipVar * resp)
{
   ClipFile *file = 0;

   int r = 0;

   ClipBlock b;

   ClipCodeVar c;

   long hash;

   char *e = strrchr(name, '.');

   char *s = strrchr(name, '/');

   c.union_of_ClipCodeVar.ClipBlock_block_of_ClipCodeVar = &b;
   if (e && (!s || s < e))
   {
      if (!strcmp(e, ".po") || !strcmp(e, ".pa"))
      {
	 file = NEW(ClipFile);
	 r = load_pobj(ClipMachineMemory, file, name, 0);
      }
      else if (!strcasecmp(e, DLLREALSUFF))
      {
	 r = load_dll(ClipMachineMemory, name, names, resp);
	 return r;
      }
      else
      {
	 _clip_trap_printf(ClipMachineMemory, __FILE__, __LINE__, "unknown file type: '%s'", name);
	 return _clip_call_errblock(ClipMachineMemory, 1);
      }
   }
   else
   {
      char path[256];

      snprintf(path, sizeof(path), "%s.po", name);
      if (!access(path, R_OK))
      {
	 file = NEW(ClipFile);
	 r = load_pobj(ClipMachineMemory, file, path, 0);
      }
      else
      {
	 snprintf(path, sizeof(path), "%s.pa", name);
	 if (!access(path, R_OK))
	 {
	    file = NEW(ClipFile);
	    r = load_pobj(ClipMachineMemory, file, path, 0);
	 }
	 else
	 {
	    snprintf(path, sizeof(path), "%s%s", name, DLLREALSUFF);
	    if (!access(path, R_OK))
	    {
	       r = load_dll(ClipMachineMemory, path, names, resp);
	       return r;
	    }
	    else
	    {
	       _clip_trap_printf(ClipMachineMemory, __FILE__, __LINE__, "cannot load file: '%s'", name);
	       return _clip_call_errblock(ClipMachineMemory, 1);
	    }
	 }
      }
   }

   if (r)
      return r;

   ++file->refCount_of_ClipFile;

   for (r = _clip_first_File(file, &c, &hash); r; r = _clip_next_File(file, &c, &hash))
   {
      if (c.ClipType_type_of_ClipCodeVar.ClipVartype_type_of_ClipType == CCODE_type_of_ClipVarType)
      {
	 if (resp)
	 {
	    ClipVar *vp;

	    vp = NEW(ClipVar);

	    CLEAR_CLIPVAR(resp);
	    resp->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_MPTR_ClipFlags;
	    resp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = CCODE_type_of_ClipVarType;
	    resp->ClipRefVar_p_of_ClipVar.ClipVar_of_ClipRefVar = vp;

	    vp->ClipType_t_of_ClipVar.count_of_ClipType = 1;
	    vp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = CCODE_type_of_ClipVarType;
	    vp->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_NONE_ClipFlags;
	    vp->ClipCodeVar_c_of_ClipVar.union_of_ClipCodeVar.ClipFunction_function_of_ClipCodeVar = c.union_of_ClipCodeVar.ClipFunction_function_of_ClipCodeVar;
	    ++file->refCount_of_ClipFile;
	    break;
	 }
	 else
	 {
	    if (_clip_register_hash(ClipMachineMemory, c.union_of_ClipCodeVar.ClipFunction_function_of_ClipCodeVar, hash))
	       ++file->refCount_of_ClipFile;
	 }
      }
      else if (c.ClipType_type_of_ClipCodeVar.ClipVartype_type_of_ClipType == PCODE_type_of_ClipVarType)
      {
	 if (resp)
	 {
	    ClipVar *vp;

	    ClipBlock *bp;

	    vp = NEW(ClipVar);
	    bp = NEW(ClipBlock);

	    CLEAR_CLIPVAR(resp);
	    resp->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_MPTR_ClipFlags;
	    resp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = PCODE_type_of_ClipVarType;
	    resp->ClipRefVar_p_of_ClipVar.ClipVar_of_ClipRefVar = vp;

	    vp->ClipType_t_of_ClipVar.count_of_ClipType = 1;
	    vp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = PCODE_type_of_ClipVarType;
	    vp->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_NONE_ClipFlags;
	    *bp = *c.union_of_ClipCodeVar.ClipBlock_block_of_ClipCodeVar;
	    vp->ClipCodeVar_c_of_ClipVar.union_of_ClipCodeVar.ClipBlock_block_of_ClipCodeVar = bp;
	    ++file->refCount_of_ClipFile;
	    break;
	 }
	 else
	 {
	    if (_clip_register_block(ClipMachineMemory, *c.union_of_ClipCodeVar.ClipBlock_block_of_ClipCodeVar, hash))
	    {
	       char *name;

	       if (names)
	       {
		  name = get_proc_name(&c);
		  append_Coll(names, strdup(name));
	       }

	       ++file->refCount_of_ClipFile;
	    }
	 }
      }
   }

   _clip_load_inits(ClipMachineMemory, file);

   delete_ClipFile(ClipMachineMemory, file);

   return 0;
}