INT_PTR CALLBACK OptDlgProc(HWND hDlg,UINT msg,WPARAM wparam,LPARAM lparam) { RECT rect; plgsettings *ps; //0: current; 1: original logmsg("OptDlgProc"); switch(msg){ case WM_INITDIALOG: logmsg("OptDlgProc::INITDIALOG"); TranslateDialogDefault(hDlg); ps=(plgsettings*)malloc(sizeof(plgsettings)*2); loadDBSettings(&ps[0]); ps[1]=ps[0]; SetWindowLongPtr(hDlg, GWLP_USERDATA, (LONG_PTR)ps); SetWindowLongPtr(hwnd, GWL_STYLE, WS_POPUP | WS_SIZEBOX); SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED); SetWindowLongPtr(GetDlgItem(hDlg,IDC_TREE1),GWL_STYLE,GetWindowLongPtr(GetDlgItem(hDlg,IDC_TREE1),GWL_STYLE)|TVS_NOHSCROLL|TVS_CHECKBOXES); SetWindowLongPtr(GetDlgItem(hDlg,IDC_TREE2),GWL_STYLE,GetWindowLongPtr(GetDlgItem(hDlg,IDC_TREE1),GWL_STYLE)|TVS_NOHSCROLL|TVS_CHECKBOXES); CheckDlgButton(hDlg, IDC_RADIO1+ps->align-1, BST_CHECKED); CheckDlgButton(hDlg, IDC_RADIO10+9-ps->salign, BST_CHECKED); CheckDlgButton(hDlg, IDC_CHECK1, ps->altShadow); CheckDlgButton(hDlg, IDC_CHECK2, ps->showMsgWindow); CheckDlgButton(hDlg, IDC_CHECK3, ps->transparent); CheckDlgButton(hDlg, IDC_CHECK4, ps->showShadow); CheckDlgButton(hDlg, IDC_CHECK5, ps->messages); SetDlgItemText(hDlg, IDC_EDIT2, ps->msgformat); CheckDlgButton(hDlg, IDC_CHECK6, ps->a_user); CheckDlgButton(hDlg, IDC_CHECK7, ps->showmystatus); SetDlgItemInt(hDlg, IDC_EDIT1, ps->distance, 0); SendDlgItemMessage(hDlg, IDC_SLIDER1, TBM_SETRANGE, 0, MAKELONG(0, 255)); SendDlgItemMessage(hDlg, IDC_SLIDER1, TBM_SETPOS, TRUE, (LPARAM)ps->alpha); { TCHAR buf[20]; mir_sntprintf(buf, SIZEOF(buf), _T("%d %%"), ps->alpha*100/255); SetDlgItemText(hDlg, IDC_ALPHATXT, buf); } SetDlgItemInt(hDlg, IDC_EDIT5, ps->timeout, 0); FillCheckBoxTree(GetDlgItem(hDlg, IDC_TREE1), ps->announce); FillCheckBoxTree(GetDlgItem(hDlg, IDC_TREE2), ps->showWhen); return 0; case WM_HSCROLL: if (LOWORD(wparam)==SB_ENDSCROLL||LOWORD(wparam)==SB_THUMBPOSITION||LOWORD(wparam)==SB_ENDSCROLL) return 0; ps=(plgsettings*)GetWindowLongPtr(hDlg, GWLP_USERDATA); ps->alpha=SendDlgItemMessage(hDlg, IDC_SLIDER1, TBM_GETPOS, 0, 0); { TCHAR buf[20]; mir_sntprintf(buf, SIZEOF(buf), _T("%d %%"), ps->alpha*100/255); SetDlgItemText(hDlg, IDC_ALPHATXT, buf); } goto xxx; case WM_DESTROY: logmsg("OptDlgProc::DESTROY"); ps=(plgsettings*)GetWindowLongPtr(hDlg, GWLP_USERDATA); ps[0]=ps[1]; saveDBSettings(&ps[0]); SetWindowLongPtr(hwnd, GWL_STYLE, WS_POPUP); SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED); SetWindowPos(hwnd, 0, ps->winxpos, ps->winypos, ps->winx, ps->winy, SWP_NOZORDER|SWP_NOACTIVATE); SetLayeredWindowAttributes(hwnd, ps->bkclr, ps->alpha, (ps->transparent?LWA_COLORKEY:0)|LWA_ALPHA); free((void*)GetWindowLongPtr(hDlg, GWLP_USERDATA)); return 0; case WM_COMMAND: logmsg("OptDlgProc::COMMAND"); ps=(plgsettings*)GetWindowLongPtr(hDlg, GWLP_USERDATA); switch (LOWORD(wparam)) { case IDC_BUTTON7: MessageBox(hDlg, TranslateT("Variables:\n %n : Nick\n %m : Message\n %l : New line"), TranslateT("Help"), MB_ICONINFORMATION|MB_OK); return 0; case IDC_BUTTON5: SendMessage(hwnd, WM_USER+1, (WPARAM)TranslateT("Miranda NG is great and this is a long message."), 0); break; case IDC_BUTTON1: selectFont(hDlg, &(ps->lf)); break; case IDC_BUTTON2: selectColor(hDlg, &ps->clr_status); break; case IDC_BUTTON6: selectColor(hDlg, &ps->clr_msg); break; case IDC_BUTTON3: selectColor(hDlg, &ps->clr_shadow); break; case IDC_BUTTON4: selectColor(hDlg, &ps->bkclr); break; case IDC_CHECK4: ps->showShadow=IsDlgButtonChecked(hDlg, IDC_CHECK4); break; case IDC_CHECK1: ps->altShadow=IsDlgButtonChecked(hDlg, IDC_CHECK1); break; case IDC_CHECK2: ps->showMsgWindow=IsDlgButtonChecked(hDlg, IDC_CHECK2); case IDC_EDIT1: ps->distance=GetDlgItemInt(hDlg, IDC_EDIT1, 0, 0); break; case IDC_EDIT5: ps->timeout=GetDlgItemInt(hDlg, IDC_EDIT5, 0, 0); break; case IDC_CHECK3: ps->transparent=IsDlgButtonChecked(hDlg, IDC_CHECK3); break; case IDC_CHECK5: ps->messages=IsDlgButtonChecked(hDlg, IDC_CHECK5); break; case IDC_CHECK6: ps->a_user=IsDlgButtonChecked(hDlg, IDC_CHECK6); break; case IDC_CHECK7: ps->showmystatus=IsDlgButtonChecked(hDlg, IDC_CHECK7); break; case IDC_RADIO1: case IDC_RADIO2: case IDC_RADIO3: case IDC_RADIO4: case IDC_RADIO5: case IDC_RADIO6: case IDC_RADIO7: case IDC_RADIO8: case IDC_RADIO9: if (IsDlgButtonChecked(hDlg, LOWORD(wparam))) ps->align=LOWORD(wparam)-IDC_RADIO1+1; break; case IDC_RADIO10: case IDC_RADIO11: case IDC_RADIO12: case IDC_RADIO13: case IDC_RADIO14: case IDC_RADIO15: case IDC_RADIO16: case IDC_RADIO17: case IDC_RADIO18: if (IsDlgButtonChecked(hDlg, LOWORD(wparam))) ps->salign=10-(LOWORD(wparam)-IDC_RADIO10+1); break; } xxx: saveDBSettings(ps); SetWindowPos(hwnd, 0, 0, 0, ps->winx, ps->winy, SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE); SetLayeredWindowAttributes(hwnd, db_get_dw(NULL,THIS_MODULE, "bkclr", DEFAULT_BKCLR), db_get_b(NULL,THIS_MODULE, "alpha", DEFAULT_ALPHA), (db_get_b(NULL,THIS_MODULE, "transparent", DEFAULT_TRANPARENT)?LWA_COLORKEY:0)|LWA_ALPHA); InvalidateRect(hwnd, 0, TRUE); SendMessage(GetParent(hDlg),PSM_CHANGED,0,0); return 0; case WM_NOTIFY: logmsg("OptDlgProc::NOTIFY"); switch(((LPNMHDR)lparam)->code){ case TVN_SETDISPINFO: case NM_CLICK: case NM_RETURN: case TVN_SELCHANGED: if (((LPNMHDR)lparam)->idFrom==IDC_TREE1) SendMessage(GetParent(hDlg),PSM_CHANGED,0,0); break; case PSN_APPLY: ps=(plgsettings*)GetWindowLongPtr(hDlg, GWLP_USERDATA); GetWindowRect(hwnd, &rect); ps->winx=rect.right-rect.left; ps->winy=rect.bottom-rect.top; ps->winxpos=rect.left; ps->winypos=rect.top; ps->announce=MakeCheckBoxTreeFlags(GetDlgItem(hDlg, IDC_TREE1)); ps->showWhen=MakeCheckBoxTreeFlags(GetDlgItem(hDlg, IDC_TREE2)); GetDlgItemText(hDlg, IDC_EDIT2, ps->msgformat, 255); ps[1]=ps[0]; //apply current settings at closing saveDBSettings(ps); SetLayeredWindowAttributes(hwnd, db_get_dw(NULL,THIS_MODULE, "bkclr", DEFAULT_BKCLR), db_get_b(NULL,THIS_MODULE, "alpha", DEFAULT_ALPHA), (db_get_b(NULL,THIS_MODULE, "transparent", DEFAULT_TRANPARENT)?LWA_COLORKEY:0)|LWA_ALPHA); InvalidateRect(hwnd, 0, TRUE); break; } break; } return 0; }
static int monitor_application(pid_t app_pid) { monitored_pid = app_pid; signal (SIGTERM, sandbox_handler); EUID_USER(); int status = 0; while (monitored_pid) { usleep(20000); char *msg; if (asprintf(&msg, "monitoring pid %d\n", monitored_pid) == -1) errExit("asprintf"); logmsg(msg); if (arg_debug) printf("%s\n", msg); free(msg); pid_t rv; do { rv = waitpid(-1, &status, 0); if (rv == -1) break; } while(rv != monitored_pid); if (arg_debug) printf("Sandbox monitor: waitpid %u retval %d status %d\n", monitored_pid, rv, status); DIR *dir; if (!(dir = opendir("/proc"))) { // sleep 2 seconds and try again sleep(2); if (!(dir = opendir("/proc"))) { fprintf(stderr, "Error: cannot open /proc directory\n"); exit(1); } } struct dirent *entry; monitored_pid = 0; while ((entry = readdir(dir)) != NULL) { unsigned pid; if (sscanf(entry->d_name, "%u", &pid) != 1) continue; if (pid == 1) continue; // todo: make this generic // Dillo browser leaves a dpid process running, we need to shut it down if (strcmp(cfg.command_name, "dillo") == 0) { char *pidname = pid_proc_comm(pid); if (pidname && strcmp(pidname, "dpid") == 0) break; free(pidname); } monitored_pid = pid; break; } closedir(dir); if (monitored_pid != 0 && arg_debug) printf("Sandbox monitor: monitoring %u\n", monitored_pid); } // return the latest exit status. return status; #if 0 // todo: find a way to shut down interfaces before closing the namespace // the problem is we don't have enough privileges to shutdown interfaces in this moment // shut down bridge/macvlan interfaces if (any_bridge_configured()) { if (cfg.bridge0.configured) { printf("Shutting down %s\n", cfg.bridge0.devsandbox); net_if_down( cfg.bridge0.devsandbox); } if (cfg.bridge1.configured) { printf("Shutting down %s\n", cfg.bridge1.devsandbox); net_if_down( cfg.bridge1.devsandbox); } if (cfg.bridge2.configured) { printf("Shutting down %s\n", cfg.bridge2.devsandbox); net_if_down( cfg.bridge2.devsandbox); } if (cfg.bridge3.configured) { printf("Shutting down %s\n", cfg.bridge3.devsandbox); net_if_down( cfg.bridge3.devsandbox); } usleep(20000); // 20 ms sleep } #endif }
int check_domain_specific_order(const char *sd, config_key attrib_num, __nis_table_mapping_t *table_mapping, __yp_domain_context_t *ypDomains) { __nis_table_mapping_t *t; char *myself = "check_domain_specific_order"; char *type; char *dbId = 0; int i, len; int match = 0; if (ypDomains) { if (!ypDomains->numDomains) { logmsg(MSG_NOTIMECHECK, LOG_ERR, "%s:No domains specified.", myself); return (-1); } } else { logmsg(MSG_NOTIMECHECK, LOG_ERR, "%s:No domain structure supplied.", myself); return (-1); } for (i = 0; i < ypDomains->numDomains; i++) { for (t = table_mapping; t != NULL; t = t->next) { len = strlen(sd); if ((strcasecmp(t->dbId, sd) == 0) && (len == strlen(t->dbId))) /* prevent from matching against itself */ continue; dbId = s_strndup(t->dbId, strlen(t->dbId)); if (dbId == NULL) { logmsg(MSG_NOMEM, LOG_ERR, "%s:Memory allocation error.", myself); return (-1); } if (getfullmapname(&dbId, ypDomains->domainLabels[i])) { logmsg(MSG_NOTIMECHECK, LOG_ERR, "Error getting fully qualified name for %s", dbId); free(dbId); return (-1); } if ((strcasecmp(dbId, sd) == 0) && (len == strlen(dbId))) { match = 0; switch (attrib_num) { case key_yp_map_flags: if (t->usedns_flag != 0 || t->securemap_flag != 0) match = 1; type = YP_MAP_FLAGS; break; case key_yp_comment_char: if (t->commentChar != DEFAULT_COMMENT_CHAR) match = 1; type = YP_COMMENT_CHAR; break; case key_yp_repeated_field_separators: if (t->separatorStr != DEFAULT_SEP_STRING) match = 1; type = YP_REPEATED_FIELD_SEPARATORS; break; case key_yp_name_fields: if (t->e && t->numColumns) match = 1; type = YP_NAME_FIELDS; case key_yp_split_field: if (t->e && t->numColumns) match = 1; type = YP_SPLIT_FIELD; break; case key_yp_db_id_map: if (t->objName) match = 1; type = YP_DB_ID_MAP; break; case key_yp_entry_ttl: if (t->initTtlLo != (time_t)NO_VALUE_SET) match = 1; type = YP_ENTRY_TTL; break; case key_yp_ldap_object_dn: if (t->objectDN) match = 1; type = YP_LDAP_OBJECT_DN; break; case key_nis_to_ldap_map: if (t->ruleToLDAP) match = 1; type = NIS_TO_LDAP_MAP; break; case key_ldap_to_nis_map: if (t->ruleFromLDAP) match = 1; type = LDAP_TO_NIS_MAP; break; default: type = "unknown"; match = 0; break; } /* end of switch */ if (match) { logmsg(MSG_NOTIMECHECK, LOG_ERR, "Relative attribute '%s' of type '%s' found before fully qualified one '%s'", t->dbId, type, sd); free(dbId); dbId = NULL; return (1); } } /* end of strncasecmp */ free(dbId); dbId = NULL; } /* end of t loop */ } /* end of i loop */ if (dbId) free(dbId); dbId = NULL; return (0); }
/* * note we inherited assumed authority from parent process */ static int lgssc_kr_negotiate(key_serial_t keyid, struct lgss_cred *cred, struct keyring_upcall_param *kup) { struct lgss_nego_data lnd; gss_buffer_desc token = GSS_C_EMPTY_BUFFER; OM_uint32 min_stat; int rc = -1; logmsg(LL_TRACE, "child start on behalf of key %08x: " "cred %p, uid %u, svc %u, nid %llx, uids: %u:%u/%u:%u\n", keyid, cred, cred->lc_uid, cred->lc_tgt_svc, cred->lc_tgt_nid, kup->kup_uid, kup->kup_gid, kup->kup_fsuid, kup->kup_fsgid); if (lgss_get_service_str(&g_service, kup->kup_svc, kup->kup_nid)) { logmsg(LL_ERR, "key %08x: failed to construct service " "string\n", keyid); error_kernel_key(keyid, -EACCES, 0); goto out_cred; } if (lgss_using_cred(cred)) { logmsg(LL_ERR, "key %08x: can't using cred\n", keyid); error_kernel_key(keyid, -EACCES, 0); goto out_cred; } if (lgssc_init_nego_data(&lnd, kup, cred->lc_mech->lmt_mech_n)) { logmsg(LL_ERR, "key %08x: failed to initialize " "negotiation data\n", keyid); error_kernel_key(keyid, lnd.lnd_rpc_err, lnd.lnd_gss_err); goto out_cred; } rc = lgssc_negotiation(&lnd); if (rc) { logmsg(LL_ERR, "key %08x: failed to negotiation\n", keyid); error_kernel_key(keyid, lnd.lnd_rpc_err, lnd.lnd_gss_err); goto out; } rc = serialize_context_for_kernel(lnd.lnd_ctx, &token, lnd.lnd_mech); if (rc) { logmsg(LL_ERR, "key %08x: failed to export context\n", keyid); error_kernel_key(keyid, rc, lnd.lnd_gss_err); goto out; } rc = update_kernel_key(keyid, &lnd, &token); if (rc) goto out; rc = 0; logmsg(LL_INFO, "key %08x for user %u is updated OK!\n", keyid, kup->kup_uid); out: if (token.length != 0) gss_release_buffer(&min_stat, &token); lgssc_fini_nego_data(&lnd); out_cred: lgss_release_cred(cred); return rc; }
int do_nego_rpc(struct lgss_nego_data *lnd, gss_buffer_desc *gss_token, struct lgss_init_res *gr) { struct lgssd_ioctl_param param; struct passwd *pw; int fd, ret, res; char outbuf[8192]; unsigned int *p; logmsg(LL_TRACE, "start negotiation rpc\n"); pw = getpwuid(lnd->lnd_uid); if (!pw) { logmsg(LL_ERR, "no uid %u in local user database\n", lnd->lnd_uid); return -EACCES; } param.version = GSSD_INTERFACE_VERSION; param.secid = lnd->lnd_secid; param.uuid = lnd->lnd_uuid; param.lustre_svc = lnd->lnd_lsvc; param.uid = lnd->lnd_uid; param.gid = pw->pw_gid; param.send_token_size = gss_token->length; param.send_token = (char *) gss_token->value; param.reply_buf_size = sizeof(outbuf); param.reply_buf = outbuf; logmsg(LL_TRACE, "to open " INIT_CHANNEL "\n"); fd = open(INIT_CHANNEL, O_WRONLY); if (fd < 0) { logmsg(LL_ERR, "can't open " INIT_CHANNEL "\n"); return -EACCES; } logmsg(LL_TRACE, "to down-write\n"); ret = write(fd, ¶m, sizeof(param)); if (ret != sizeof(param)) { logmsg(LL_ERR, "lustre ioctl err: %d\n", strerror(errno)); close(fd); return -EACCES; } close(fd); logmsg(LL_TRACE, "do_nego_rpc: to parse reply\n"); if (param.status) { logmsg(LL_ERR, "status: %d (%s)\n", param.status, strerror((int)param.status)); /* kernel return -ETIMEDOUT means the rpc timedout, we should * notify the caller to reinitiate the gss negotiation, by * returning -ERESTART */ if (param.status == -ETIMEDOUT) return -ERESTART; else return param.status; } p = (unsigned int *)outbuf; res = *p++; gr->gr_major = *p++; gr->gr_minor = *p++; gr->gr_win = *p++; gr->gr_ctx.length = *p++; gr->gr_ctx.value = malloc(gr->gr_ctx.length); memcpy(gr->gr_ctx.value, p, gr->gr_ctx.length); p += (((gr->gr_ctx.length + 3) & ~3) / 4); gr->gr_token.length = *p++; gr->gr_token.value = malloc(gr->gr_token.length); memcpy(gr->gr_token.value, p, gr->gr_token.length); p += (((gr->gr_token.length + 3) & ~3) / 4); logmsg(LL_DEBUG, "do_nego_rpc: receive handle len %d, token len %d\n", gr->gr_ctx.length, gr->gr_token.length); return 0; }
/*-------------------------------------------------------------------*/ int unbind_device_ex (DEVBLK* dev, int forced) { bind_struct* bs; logdebug("unbind_device(%4.4X)\n", dev->devnum); /* Error if device not bound */ if (!(bs = dev->bs)) { logmsg (_("HHCSD005E Device %4.4X not bound to any socket\n"), dev->devnum); return 0; /* (failure) */ } /* Is anyone still connected? */ if (dev->fd != -1) { /* Yes. Should we forcibly disconnect them? */ if (forced) { /* Yes. Then do so... */ close_socket( dev->fd ); dev->fd = -1; logmsg (_("HHCSD025I Client %s (%s) disconnected from device %4.4X (%s)\n"), dev->bs->clientip, dev->bs->clientname, dev->devnum, dev->bs->spec); } else { /* No. Then fail the request. */ logmsg (_("HHCSD006E Client %s (%s) still connected to device %4.4X (%s)\n"), dev->bs->clientip, dev->bs->clientname, dev->devnum, dev->bs->spec); return 0; /* (failure) */ } } /* Remove the entry from our list */ obtain_lock( &bind_lock ); RemoveListEntry( &bs->bind_link ); SIGNAL_SOCKDEV_THREAD(); release_lock( &bind_lock ); logmsg (_("HHCSD007I Device %4.4X unbound from socket %s\n"), dev->devnum, bs->spec); if (bs->sd != -1) close_socket (bs->sd); /* Unchain device and bind_struct from each another */ dev->bs = NULL; bs->dev = NULL; /* Discard the entry */ if ( bs->clientname ) free( bs->clientname ); if ( bs->clientip ) free( bs->clientip ); bs->clientname = NULL; bs->clientip = NULL; free ( bs->spec ); free ( bs ); return 1; /* (success) */ }
/*-------------------------------------------------------------------*/ void socket_device_connection_handler (bind_struct* bs) { struct sockaddr_in client; /* Client address structure */ struct hostent* pHE; /* Addr of hostent structure */ socklen_t namelen; /* Length of client structure*/ char* clientip; /* Addr of client ip address */ char* clientname; /* Addr of client hostname */ DEVBLK* dev; /* Device Block pointer */ int csock; /* Client socket */ dev = bs->dev; logdebug("socket_device_connection_handler(dev=%4.4X)\n", dev->devnum); /* Accept the connection... */ csock = accept(bs->sd, 0, 0); if (csock == -1) { logmsg (_("HHCSD017E Connect to device %4.4X (%s) failed: %s\n"), dev->devnum, bs->spec, strerror(HSO_errno)); return; } /* Determine the connected client's IP address and hostname */ namelen = sizeof(client); clientip = NULL; clientname = "<unknown>"; if (1 && getpeername(csock, (struct sockaddr*) &client, &namelen) == 0 && (clientip = inet_ntoa(client.sin_addr)) != NULL && (pHE = gethostbyaddr((unsigned char*)(&client.sin_addr), sizeof(client.sin_addr), AF_INET)) != NULL && pHE->h_name && *pHE->h_name ) { clientname = (char*) pHE->h_name; } if (!clientip) clientip = "<unknown>"; /* Obtain the device lock */ obtain_lock (&dev->lock); /* Reject if device is busy or interrupt pending */ if (dev->busy || IOPENDING(dev) || (dev->scsw.flag3 & SCSW3_SC_PEND)) { close_socket( csock ); logmsg (_("HHCSD015E Client %s (%s) connection to device %4.4X " "(%s) rejected: device busy or interrupt pending\n"), clientname, clientip, dev->devnum, bs->spec); release_lock (&dev->lock); return; } /* Reject new client if previous client still connected */ if (dev->fd != -1) { close_socket( csock ); logmsg (_("HHCSD016E Client %s (%s) connection to device %4.4X " "(%s) rejected: client %s (%s) still connected\n"), clientname, clientip, dev->devnum, bs->spec, bs->clientname, bs->clientip); release_lock (&dev->lock); return; } /* Indicate that a client is now connected to this device */ dev->fd = csock; if (bs->clientip) free(bs->clientip); if (bs->clientname) free(bs->clientname); bs->clientip = strdup(clientip); bs->clientname = strdup(clientname); /* Call the boolean onconnect callback */ if (bs->fn && !bs->fn( bs->arg )) { /* Callback says it can't accept it */ close_socket( dev->fd ); dev->fd = -1; logmsg (_("HHCSD026E Client %s (%s) connection to device %4.4X " "(%s) rejected: by onconnect callback\n"), clientname, clientip, dev->devnum, bs->spec); release_lock (&dev->lock); return; } logmsg (_("HHCSD018I Client %s (%s) connected to device %4.4X (%s)\n"), clientname, clientip, dev->devnum, bs->spec); release_lock (&dev->lock); device_attention (dev, CSW_DE); }
/* based on syslogd privsep */ int priv_init(void) { int i, fd, socks[2], cmd; int snaplen, ret, olderrno; struct passwd *pw; for (i = 1; i < _NSIG; i++) signal(i, SIG_DFL); /* Create sockets */ if (socketpair(AF_LOCAL, SOCK_STREAM, PF_UNSPEC, socks) == -1) err(1, "socketpair() failed"); pw = getpwnam("_pflogd"); if (pw == NULL) errx(1, "unknown user _pflogd"); endpwent(); child_pid = fork(); if (child_pid < 0) err(1, "fork() failed"); if (!child_pid) { gid_t gidset[1]; /* Child - drop privileges and return */ if (chroot(pw->pw_dir) != 0) err(1, "unable to chroot"); if (chdir("/") != 0) err(1, "unable to chdir"); gidset[0] = pw->pw_gid; if (setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) == -1) err(1, "setresgid() failed"); if (setgroups(1, gidset) == -1) err(1, "setgroups() failed"); if (setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid) == -1) err(1, "setresuid() failed"); close(socks[0]); priv_fd = socks[1]; return 0; } /* Father */ /* Pass ALRM/TERM/HUP/INT/QUIT through to child, and accept CHLD */ signal(SIGALRM, sig_pass_to_chld); signal(SIGTERM, sig_pass_to_chld); signal(SIGHUP, sig_pass_to_chld); signal(SIGINT, sig_pass_to_chld); signal(SIGQUIT, sig_pass_to_chld); signal(SIGCHLD, sig_chld); setproctitle("[priv]"); close(socks[1]); while (!gotsig_chld) { if (may_read(socks[0], &cmd, sizeof(int))) break; switch (cmd) { case PRIV_SET_SNAPLEN: logmsg(LOG_DEBUG, "[priv]: msg PRIV_SET_SNAPLENGTH received"); must_read(socks[0], &snaplen, sizeof(int)); ret = set_snaplen(snaplen); if (ret) { logmsg(LOG_NOTICE, "[priv]: set_snaplen failed for snaplen %d", snaplen); } must_write(socks[0], &ret, sizeof(int)); break; case PRIV_OPEN_LOG: logmsg(LOG_DEBUG, "[priv]: msg PRIV_OPEN_LOG received"); /* create or append logs but do not follow symlinks */ fd = open(filename, O_RDWR|O_CREAT|O_APPEND|O_NONBLOCK|O_NOFOLLOW, 0600); olderrno = errno; send_fd(socks[0], fd); if (fd < 0) logmsg(LOG_NOTICE, "[priv]: failed to open %s: %s", filename, strerror(olderrno)); else close(fd); break; case PRIV_MOVE_LOG: logmsg(LOG_DEBUG, "[priv]: msg PRIV_MOVE_LOG received"); ret = move_log(filename); must_write(socks[0], &ret, sizeof(int)); break; default: logmsg(LOG_ERR, "[priv]: unknown command %d", cmd); _exit(1); /* NOTREACHED */ } } _exit(1); }
static int kbd_get_i2cdev(void) { char buf[PATH_MAX]; int i2c_bus; int ret; FILE *fp; /* All the 256 minors (major 89) are reserved for i2c adapters */ for (i2c_bus = 0; i2c_bus < 256; i2c_bus++) { ret = snprintf(buf, PATH_MAX - 1, "%s/i2c-%d/name", SYSFS_I2C_BASE, i2c_bus); if ((ret < 0) || (ret >= (PATH_MAX - 1))) { logmsg(LOG_WARNING, "Error: i2c device probe: device path too long"); i2c_bus = 256; break; } fp = fopen(buf, "r"); if (fp == NULL) { if (errno != ENOENT) { logmsg(LOG_ERR, "Error: i2c device probe: cannot open %s: %s", buf, strerror(errno)); continue; } else { logmsg(LOG_ERR, "Error: i2c device probe: i2c device not found, is i2c-dev loaded?"); i2c_bus = 256; break; } } ret = fread(buf, 1, PATH_MAX - 1, fp); fclose(fp); if (ret < 1) continue; buf[ret - 1] = '\0'; logdebug("Found i2c adapter [%s]\n", buf); if (ret < strlen(I2C_ADAPTER_NAME)) continue; if (strncmp(buf, I2C_ADAPTER_NAME, strlen(I2C_ADAPTER_NAME)) == 0) { logmsg(LOG_INFO, "Found %s i2c adapter at i2c-%d", I2C_ADAPTER_NAME, i2c_bus); break; } } if (i2c_bus > 255) return -1; ret = snprintf(lmu_info.i2cdev, sizeof(lmu_info.i2cdev) - 1, "/dev/i2c-%d", i2c_bus); if ((ret < 0) || (ret >= (sizeof(lmu_info.i2cdev) - 1))) { logmsg(LOG_WARNING, "Error: i2c device path too long"); return -1; } return 0; }
static curl_socket_t sockdaemon(curl_socket_t sock, unsigned short *port) { /* passive daemon style */ struct sockaddr_in me; #ifdef ENABLE_IPV6 struct sockaddr_in6 me6; #endif /* ENABLE_IPV6 */ int flag = 1; int rc; if (setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag)) < 0) { perror("setsockopt(SO_REUSEADDR)"); } #ifdef ENABLE_IPV6 if(!use_ipv6) { #endif me.sin_family = AF_INET; me.sin_addr.s_addr = INADDR_ANY; me.sin_port = htons(*port); rc = bind(sock, (struct sockaddr *) &me, sizeof(me)); #ifdef ENABLE_IPV6 } else { memset(&me6, 0, sizeof(struct sockaddr_in6)); me6.sin6_family = AF_INET6; me6.sin6_addr = in6addr_any; me6.sin6_port = htons(*port); rc = bind(sock, (struct sockaddr *) &me6, sizeof(me6)); } #endif /* ENABLE_IPV6 */ if(rc < 0) { perror("binding stream socket"); logmsg("Error binding socket"); return CURL_SOCKET_BAD; } if(!*port) { /* The system picked a port number, now figure out which port we actually got */ /* we succeeded to bind */ struct sockaddr_in add; socklen_t socksize = sizeof(add); if(getsockname(sock, (struct sockaddr *) &add, &socksize)<0) { logmsg("getsockname() failed with error: %d", SOCKERRNO); return CURL_SOCKET_BAD; } *port = ntohs(add.sin_port); } /* start accepting connections */ rc = listen(sock, 4); if(0 != rc) { logmsg("listen() failed with error: %d", SOCKERRNO); sclose(sock); return CURL_SOCKET_BAD; } return sock; }
/* sockfdp is a pointer to an established stream or CURL_SOCKET_BAD if sockfd is CURL_SOCKET_BAD, listendfd is a listening socket we must accept() */ static int juggle(curl_socket_t *sockfdp, curl_socket_t listenfd, enum sockmode *mode) { struct timeval timeout; fd_set fds_read; fd_set fds_write; fd_set fds_err; curl_socket_t sockfd; curl_socket_t maxfd; ssize_t rc; ssize_t nread_stdin; ssize_t nread_socket; ssize_t bytes_written; ssize_t buffer_len; unsigned char buffer[256]; /* FIX: bigger buffer */ char data[256]; timeout.tv_sec = 120; timeout.tv_usec = 0; FD_ZERO(&fds_read); FD_ZERO(&fds_write); FD_ZERO(&fds_err); FD_SET(fileno(stdin), &fds_read); switch(*mode) { case PASSIVE_LISTEN: /* server mode */ sockfd = listenfd; /* there's always a socket to wait for */ FD_SET(sockfd, &fds_read); maxfd = sockfd; break; case PASSIVE_CONNECT: sockfd = *sockfdp; if(CURL_SOCKET_BAD == sockfd) { /* eeek, we are supposedly connected and then this cannot be -1 ! */ logmsg("socket is -1! on %s:%d", __FILE__, __LINE__); maxfd = 0; /* stdin */ } else { /* there's always a socket to wait for */ FD_SET(sockfd, &fds_read); maxfd = sockfd; } break; case ACTIVE: sockfd = *sockfdp; /* sockfd turns CURL_SOCKET_BAD when our connection has been closed */ if(CURL_SOCKET_BAD != sockfd) { FD_SET(sockfd, &fds_read); maxfd = sockfd; } else { logmsg("No socket to read on"); maxfd = 0; } break; case ACTIVE_DISCONNECT: logmsg("disconnected, no socket to read on"); maxfd = 0; sockfd = CURL_SOCKET_BAD; break; } /* switch(*mode) */ do { rc = select(maxfd + 1, &fds_read, &fds_write, &fds_err, &timeout); } while((rc == -1) && (SOCKERRNO == EINTR)); switch(rc) { case -1: return FALSE; case 0: /* timeout! */ return TRUE; } if(FD_ISSET(fileno(stdin), &fds_read)) { /* read from stdin, commands/data to be dealt with and possibly passed on to the socket protocol: 4 letter command + LF [mandatory] 4-digit hexadecimal data length + LF [if the command takes data] data [the data being as long as set above] Commands: DATA - plain pass-thru data */ nread_stdin = read(fileno(stdin), buffer, 5); if(5 == nread_stdin) { logmsg("Received %c%c%c%c (on stdin)", buffer[0], buffer[1], buffer[2], buffer[3] ); if(!memcmp("PING", buffer, 4)) { /* send reply on stdout, just proving we are alive */ write(fileno(stdout), "PONG\n", 5); } else if(!memcmp("PORT", buffer, 4)) { /* Question asking us what PORT number we are listening to. Replies to PORT with "IPv[num]/[port]" */ sprintf((char *)buffer, "IPv%d/%d\n", use_ipv6?6:4, (int)port); buffer_len = (ssize_t)strlen((char *)buffer); sprintf(data, "PORT\n%04x\n", buffer_len); write(fileno(stdout), data, 10); write(fileno(stdout), buffer, buffer_len); } else if(!memcmp("QUIT", buffer, 4)) { /* just die */ logmsg("quits"); return FALSE; } else if(!memcmp("DATA", buffer, 4)) { /* data IN => data OUT */ if(5 != read(fileno(stdin), buffer, 5)) return FALSE; buffer[5] = '\0'; buffer_len = (ssize_t)strtol((char *)buffer, NULL, 16); if (buffer_len > (ssize_t)sizeof(buffer)) { logmsg("Buffer size %d too small for data size %d", (int)sizeof(buffer), buffer_len); return FALSE; } nread_stdin = read(fileno(stdin), buffer, buffer_len); if(nread_stdin != buffer_len) return FALSE; logmsg("> %d bytes data, server => client", buffer_len); lograw(buffer, buffer_len); if(*mode == PASSIVE_LISTEN) { logmsg("*** We are disconnected!"); write(fileno(stdout), "DISC\n", 5); } else { /* send away on the socket */ bytes_written = swrite(sockfd, buffer, buffer_len); if(bytes_written != buffer_len) { logmsg("Not all data was sent. Bytes to send: %d sent: %d", buffer_len, bytes_written); } } } else if(!memcmp("DISC", buffer, 4)) { /* disconnect! */ write(fileno(stdout), "DISC\n", 5); if(sockfd != CURL_SOCKET_BAD) { logmsg("====> Client forcibly disconnected"); sclose(sockfd); *sockfdp = CURL_SOCKET_BAD; if(*mode == PASSIVE_CONNECT) *mode = PASSIVE_LISTEN; else *mode = ACTIVE_DISCONNECT; } else logmsg("attempt to close already dead connection"); return TRUE; } } else if(-1 == nread_stdin) { logmsg("read %d from stdin, exiting", nread_stdin); return FALSE; } } if((sockfd != CURL_SOCKET_BAD) && (FD_ISSET(sockfd, &fds_read)) ) { if(*mode == PASSIVE_LISTEN) { /* there's no stream set up yet, this is an indication that there's a client connecting. */ sockfd = accept(sockfd, NULL, NULL); if(CURL_SOCKET_BAD == sockfd) logmsg("accept() failed"); else { logmsg("====> Client connect"); write(fileno(stdout), "CNCT\n", 5); *sockfdp = sockfd; /* store the new socket */ *mode = PASSIVE_CONNECT; /* we have connected */ } return TRUE; } /* read from socket, pass on data to stdout */ nread_socket = sread(sockfd, buffer, sizeof(buffer)); if(nread_socket <= 0) { logmsg("====> Client disconnect"); write(fileno(stdout), "DISC\n", 5); sclose(sockfd); *sockfdp = CURL_SOCKET_BAD; if(*mode == PASSIVE_CONNECT) *mode = PASSIVE_LISTEN; else *mode = ACTIVE_DISCONNECT; return TRUE; } sprintf(data, "DATA\n%04x\n", nread_socket); write(fileno(stdout), data, 10); write(fileno(stdout), buffer, nread_socket); logmsg("< %d bytes data, client => server", nread_socket); lograw(buffer, nread_socket); } return TRUE; }
//=============== // main function //=============== int main( int argc, char *argv[] ) { //------------------------------ // global variable declarations //------------------------------ extern volatile sig_atomic_t sig_raised; //---------------------------- // local variable definitions //---------------------------- int verbosity; int retval; int client_sock_fd; struct pollfd server_sock_pfd[MAX_SOCKETS]; int num_sockets; int nfds; int i; int argc_count; mode_t prev_umask; bool remain_foreground; bool msg_validation; bool uid_specified; bool gid_specified; bool pidfile_created; char msg[MAX_MSG_LEN + 1]; char ch; const char *appname; const char *pidfile; uid_t uid; gid_t gid; pid_t child_pid; int child_status; stringtable_t st; FILE *pidfile_stream; char **src_path; struct passwd *password_ptr; struct group *group_ptr; char *dest_path = DEFAULT_DEST; ssize_t msg_len, num_bytes; struct sockaddr_un src_addr, dest_addr; struct sigaction action; struct stat metadata; static struct option longopts[] = { { "foreground", no_argument, NULL, 'd' }, { "help", no_argument, NULL, '?' }, { "verbosity", required_argument, NULL, 'V' }, { "verbose", no_argument, NULL, 'v' }, { "quiet", no_argument, NULL, 'q' }, { "no_validation", no_argument, NULL, 'n' }, { "user", required_argument, NULL, 'u' }, { "group", required_argument, NULL, 'g' }, { "pidfile", required_argument, NULL, 'p' }, { "dest_socket", required_argument, NULL, 's' }, { NULL, 0, NULL, 0 } }; //------------------------ // set initial conditions //------------------------ sig_raised = -1; verbosity = DEFAULT_LOG_LEVEL; retval = EXIT_SUCCESS; remain_foreground = false; msg_validation = true; appname = basename(argv[0]); uid_specified = false; gid_specified = false; uid = getuid(); gid = getgid(); num_sockets = 0; pidfile = DEFAULT_PIDFILE; pidfile_created = false; client_sock_fd = 0; for(i=0; i<MAX_SOCKETS; i++) server_sock_pfd[i].fd = 0; // log to stderr during start-up log_to_stderr(true); log_to_syslog(false); log_set_threshold(verbosity); // allocate storage for socket paths if( (src_path = stringtable_create(&st, MAX_SOCKETS, STRING_TABLE_SIZE)) == NULL ) { logwarnx(LOG_ERR, "Can't create string table with %z indexes, %z bytes", MAX_SOCKETS, STRING_TABLE_SIZE); goto exit_err; } //---------------------------- // parse command line options //---------------------------- while ( (ch = getopt_long(argc, argv, "a:dDvqn?V:u:g:p:", longopts, NULL)) != -1 ) { switch (ch) { case 's': dest_path = optarg; break; case 'd': case 'D': // retained for backward compatibility with V0.1 remain_foreground = true; break; case 'V': errno = 0; verbosity = strtol(optarg, NULL, 0); if ( errno != 0 ) { logmsg(LOG_ERR, "verbosity %s: %s", strerror(errno), optarg); goto exit_err; } else log_set_threshold(verbosity); break; case 'v': verbosity++; log_set_threshold(verbosity); break; case 'q': verbosity--; log_set_threshold(verbosity); break; case 'n': msg_validation = false; break; case 'u': uid_specified = true; if( (password_ptr = getpwnam(optarg)) == NULL ) { logmsg(LOG_ERR, "user not found: %s", optarg); goto exit_err; } else uid = password_ptr->pw_uid; break; case 'g': gid_specified = true; if( (group_ptr = getgrnam(optarg)) == NULL ) { logmsg(LOG_ERR, "group not found: %s", optarg); goto exit_err; } else gid = group_ptr->gr_gid; break; case 'p': pidfile = optarg; break; case '?': default: fprintf(stderr, USAGE_STR); retval = EXIT_FAILURE; goto tidy_up; break; } } argc -= optind; argv += optind; // remaining arguments give log socket paths if( argc > 0 ) { argc_count = 0; LOOP: while(argc_count < argc) { for( i = 0; i < num_sockets - 1; i++ ) { // ignore duplicate paths if( strcmp(src_path[i], argv[argc_count]) == 0 ) { argc_count++; goto LOOP; } } if( (num_sockets = stringtable_add(&st, argv[argc_count])) == -1 ) { logwarnx(LOG_ERR, "string table full: can't add socket %s", argv[argc_count]); goto exit_err; } argc_count++; } } else { logmsg(LOG_ERR, "missing arguments"); fprintf(stderr, USAGE_STR); retval = EXIT_FAILURE; goto tidy_up; } // default to using the same GID as the UID if( uid_specified && !gid_specified ) gid = uid; //----------------- // create PID file //----------------- logmsg(LOG_DEBUG, "creating PID file %s", pidfile); if( stat(pidfile, &metadata) == 0 ) { logmsg(LOG_ERR, "error: PID file %s already exists - server may already be running", pidfile); return EXIT_FAILURE; // don't goto exit_err as this would delete the existing PID file } else { if( (pidfile_stream = fopen(pidfile, "w")) == NULL ) { if( errno == EPERM ) logmsg(LOG_WARNING, "warning: insufficient permission to create PID file %s - continuing without a PID file"); else { logwarn(LOG_ERR, "error: can't create PID file %s: fopen()", pidfile); return EXIT_FAILURE; } } else pidfile_created = true; } //------------------------------------------------------ // create input socket(s) - unix domain datagram server //------------------------------------------------------ // modify permissions mask to create socket pseudo-files as rw-rw-rw- prev_umask = umask(0111); for( i=0; i<num_sockets; i++ ) { logmsg(LOG_INFO, "input socket %s", src_path[i]); // delete stale path (if it exists and is a socket) if( stat(src_path[i], &metadata) == 0 ) { if( S_ISSOCK(metadata.st_mode) ) { if( unlink(src_path[i]) ) { logwarn(LOG_ERR, "unlink()"); goto exit_err; } } else { logmsg(LOG_ERR, "error: %s already exists as something not a socket", src_path); goto exit_err; } } // create unassigned socket if( (server_sock_pfd[i].fd = socket(AF_LOCAL, SOCK_DGRAM, 0)) == -1 ) { logwarn(LOG_ERR, "socket()"); goto exit_err; } else server_sock_pfd[i].events = POLLIN; // copy socket path into address structure bzero(&src_addr, sizeof(src_addr)); src_addr.sun_family = AF_LOCAL; strncpy(src_addr.sun_path, src_path[i], sizeof(src_addr.sun_path) - 1); // bind socket to address if( bind(server_sock_pfd[i].fd, (struct sockaddr *) &src_addr, sizeof(src_addr)) == -1 ) { logwarn(LOG_ERR, "bind()"); goto exit_err; } } // next server socket // restore original permissions mask umask(prev_umask); //---------------------------------------------------- // create output socket - unix domain datagram client //---------------------------------------------------- logmsg(LOG_DEBUG, "output socket %s", dest_path); if( (client_sock_fd = socket(AF_LOCAL, SOCK_DGRAM, 0)) == -1 ) { logwarn(LOG_ERR, "socket()"); goto exit_err; } // no need to bind to a source address because we are not expecting an answer // validate destination path if( stat(dest_path, &metadata) || !S_ISSOCK(metadata.st_mode) ) { logmsg(LOG_ERR, "error: destination path %s was not found or is not a socket"); goto exit_err; } // set up destination address (socket path) bzero(&dest_addr, sizeof(dest_addr)); dest_addr.sun_family = AF_LOCAL; strncpy(dest_addr.sun_path, dest_path, sizeof(dest_addr.sun_path) - 1); logmsg(LOG_INFO, "forwarding messages to %s", dest_path); //=========================== // start up actions complete //=========================== if( !remain_foreground ) { // detach process and close standard IO streams logmsg(LOG_INFO, "starting server - detaching process"); if( daemon(true, false) ) { logwarn(LOG_ERR, "daemon()"); goto exit_err; } else { // begin logging to syslog // log to stderr during start-up log_to_stderr(false); log_to_syslog(true); logmsg(LOG_DEBUG, "daemon alive"); } } // fork child logmsg(LOG_DEBUG, "forking child"); if( (child_pid = fork()) == -1 ) { logwarn(LOG_ERR, "fork()"); goto exit_err; } else { if( child_pid != 0 ) { //================ // PARENT PROCESS //================ // write PID to pidfile if( fprintf(pidfile_stream, "%d\n", getpid()) < 0 ) { logwarn(LOG_ERR, "error: writing PID fprintf()"); goto exit_err; } else fclose(pidfile_stream); // install signal handler for SIGINT, SIGHUP, SIGCHLD and SIGTERM action.sa_handler = signal_handler; sigemptyset( &action.sa_mask); // don't block any signals action.sa_flags = SA_NOCLDSTOP; // override default SA_RESTART behaviour and don't signal child stop/resumes logmsg(LOG_DEBUG, "installing signal handlers"); if( sig_install_action(SIGINT, &action) || sig_install_action(SIGCHLD, &action) || sig_install_action(SIGHUP, &action) || sig_install_action(SIGTERM, &action) ) goto exit_err; // parent main loop do { logmsg(LOG_DEBUG, "server running"); // wait for a signal pause(); logmsg(LOG_INFO, "caught signal: %s", strsignal(sig_raised)); // handle signal switch( sig_raised ) { case SIGCHLD: // child changed state do { logmsg(LOG_INFO, "waiting for child process to finish"); if( waitpid(child_pid, &child_status, 0) == -1 ) { logwarn(LOG_ERR, "waitpid()"); goto exit_err; } } while ( !WIFEXITED(child_status) && !WIFSIGNALED(child_status) ); break; case SIGINT: case SIGHUP: case SIGTERM: logmsg(LOG_INFO, "sending SIGTERM to child (PID %d)", child_pid); kill(child_pid, SIGTERM); sig_raised = -1; break; default: logmsg(LOG_ERR, "ignoring unrecognised signal"); sig_raised = -1; break; } } while( sig_raised == -1 ); logmsg(LOG_INFO, "server terminating"); goto normal_exit; // end of parent process } else { //=============== // CHILD PROCESS //=============== // drop privileges logmsg(LOG_INFO, "child dropping privileges to UID %d, GID %d", uid, gid); if( drop_privileges(uid, gid) ) return EXIT_FAILURE; //================= // child main loop //================= // relay messages received on input sockets while( (nfds = poll(server_sock_pfd, num_sockets, -1)) != -1 ) { // find readable input socket(s) for( i=0; i<num_sockets; i++) { if( server_sock_pfd[i].revents & (POLLERR | POLLHUP | POLLNVAL) ) { logwarn(LOG_ERR, "child: poll() %s", src_path[i]); return EXIT_FAILURE; } else if( server_sock_pfd[i].revents & POLLIN ) { // receive and relay message logmsg(LOG_INFO, "child: receiving message on server socket %s", src_path[i]); if( (msg_len = recv(server_sock_pfd[i].fd, msg, MAX_MSG_LEN, 0)) == -1 ) { if( errno == EINTR ) { logmsg(LOG_ERR, "child: caught signal: %s", strsignal(sig_raised)); goto tidy_up; } else { logwarn(LOG_ERR, "child: recv()"); goto exit_err; } } else msg[msg_len] = '\0'; logmsg(LOG_DEBUG, "child: original message (%zd bytes) \"%s\"", msg_len, msg); // validate message if( msg_validation ) { msg_len = validate_syslog_msg(msg, msg_len, MAX_MSG_LEN); msg[msg_len] = '\0'; logmsg(LOG_DEBUG, "child: post-validation message (%zd bytes) \"%s\"", msg_len, msg); } // relay message if( msg_len > 0 ) { logmsg(LOG_DEBUG, "child: relaying message (%zd bytes)", msg_len); num_bytes = sendto(client_sock_fd, msg, msg_len, 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr)); if( num_bytes == -1 && errno == EINTR ) { logmsg(LOG_ERR, "child: caught signal: %s", strsignal(sig_raised)); goto tidy_up; } else { if( num_bytes != msg_len ) logwarn(LOG_ERR, "child: relaying message: sendto()"); else logmsg(LOG_DEBUG, "child: OK, sent %zd bytes", num_bytes); } } else logmsg(LOG_ERR, "child: bad message length %zd: not relaying", msg_len); } } } logwarn(LOG_ERR, "child: poll()"); return EXIT_FAILURE; } // end of child process } //------ // done //------ normal_exit: goto tidy_up; exit_err: logmsg(LOG_ERR, "server error"); retval = EXIT_FAILURE; tidy_up: // close open descriptors for( i=0; i<num_sockets; i++) if( server_sock_pfd[i].fd && close(server_sock_pfd[i].fd) ) logwarn(LOG_ERR, "descriptor %d (server socket %s): close()", server_sock_pfd[i].fd, src_path[i]); if( client_sock_fd && close(client_sock_fd) ) logwarn(LOG_ERR, "descriptor %d (client socket %s): close()", client_sock_fd, dest_path); // delete server socket pseudo-files for( i=0; i<num_sockets; i++) { logmsg(LOG_INFO, "deleting input socket pseudo-file %s", src_path[i]); if( stat(src_path[i], &metadata) ) logwarn(LOG_ERR, "stat()"); else { if( S_ISSOCK(metadata.st_mode) ) { if( unlink(src_path[i]) ) logwarn(LOG_ERR, "unlink()"); } else { logmsg(LOG_ERR, "%s is not a socket"); } } } // delete PID file if( pidfile_created ) { logmsg(LOG_INFO, "deleting PID file"); if( unlink(pidfile) && errno != ENOENT ) logwarn(LOG_ERR, "unlink(): %s", pidfile); } // exit logmsg(LOG_INFO, "server exited"); return retval; }
int main(int argc, char *argv[]) { int argchar; char* infn = NULL; char* outfn = NULL; FILE* fout; anbool tostdout = FALSE; anqfits_t* anq; int W, H; qfits_header* hdr; const anqfits_image_t* animg; float* img; int loglvl = LOG_MSG; int scale = 2; int winw; int winh; int plane; int out_bitpix = -32; float* outimg; int outw, outh; int edge = EDGE_TRUNCATE; int ext = 0; int npixout = 0; while ((argchar = getopt (argc, argv, OPTIONS)) != -1) switch (argchar) { case 'v': loglvl++; break; case 's': scale = atoi(optarg); break; case 'e': ext = atoi(optarg); break; case '?': case 'h': printHelp(argv[0]); return 0; default: return -1; } log_init(loglvl); log_to(stderr); errors_log_to(stderr); fits_use_error_system(); if (argc - optind != 2) { logerr("Need two arguments: input and output files.\n"); printHelp(argv[0]); exit(-1); } infn = argv[optind]; outfn = argv[optind+1]; if (streq(outfn, "-")) { tostdout = TRUE; fout = stdout; } else { fout = fopen(outfn, "wb"); if (!fout) { SYSERROR("Failed to open output file \"%s\"", outfn); exit(-1); } } anq = anqfits_open(infn); if (!anq) { ERROR("Failed to open input file \"%s\"", infn); exit(-1); } animg = anqfits_get_image_const(anq, ext); W = (int)animg->width; H = (int)animg->height; if (!animg) { ERROR("Failde to read image from \"%s\"", infn); exit(-1); } /* if (tostdout) dump.filename = "STDOUT"; else dump.filename = outfn; dump.ptype = PTYPE_FLOAT; dump.out_ptype = out_bitpix; */ get_output_image_size(W % scale, H % scale, scale, edge, &outw, &outh); outw += (W / scale); outh += (H / scale); hdr = qfits_header_default(); fits_header_add_int(hdr, "BITPIX", out_bitpix, "bits per pixel"); if (animg->planes > 1) fits_header_add_int(hdr, "NAXIS", 3, "number of axes"); else fits_header_add_int(hdr, "NAXIS", 2, "number of axes"); fits_header_add_int(hdr, "NAXIS1", outw, "image width"); fits_header_add_int(hdr, "NAXIS2", outh, "image height"); if (animg->planes > 1) fits_header_add_int(hdr, "NAXIS3", animg->planes, "number of planes"); if (qfits_header_dump(hdr, fout)) { ERROR("Failed to write FITS header to \"%s\"", outfn); exit(-1); } qfits_header_destroy(hdr); winw = W; winh = (int)ceil(ceil(1024*1024 / (float)winw) / (float)scale) * scale; outimg = malloc((int)ceil(winw/scale)*(int)ceil(winh/scale) * sizeof(float)); logmsg("Image is %i x %i x %i\n", W, H, (int)animg->planes); logmsg("Output will be %i x %i x %i\n", outw, outh, (int)animg->planes); logverb("Reading in blocks of %i x %i\n", winw, winh); for (plane=0; plane<animg->planes; plane++) { int bx, by; int nx, ny; for (by=0; by<(int)ceil(H / (float)winh); by++) { for (bx=0; bx<(int)ceil(W / (float)winw); bx++) { int i; int lox, loy, hix, hiy, outw, outh; nx = MIN(winw, W - bx*winw); ny = MIN(winh, H - by*winh); lox = bx*winw; loy = by*winh; hix = lox + nx; hiy = loy + ny; logverb(" reading %i,%i + %i,%i\n", lox, loy, nx, ny); img = anqfits_readpix(anq, ext, lox, hix, loy, hiy, plane, PTYPE_FLOAT, NULL, &W, &H); if (!img) { ERROR("Failed to load pixel window: x=[%i, %i), y=[%i,%i), plane %i\n", lox, hix, loy, hiy, plane); exit(-1); } average_image_f(img, nx, ny, scale, edge, &outw, &outh, outimg); free(img); logverb(" writing %i x %i\n", outw, outh); if (outw * outh == 0) continue; for (i=0; i<outw*outh; i++) { int nbytes = abs(out_bitpix)/8; char buf[nbytes]; if (qfits_pixel_ctofits(PTYPE_FLOAT, out_bitpix, outimg + i, buf)) { ERROR("Failed to convert pixel to FITS type\n"); exit(-1); } if (fwrite(buf, nbytes, 1, fout) != 1) { ERROR("Failed to write pixels\n"); exit(-1); } } npixout += outw*outh; } } } free(outimg); anqfits_close(anq); if (tostdout) { // pad. int N; char pad[2880]; N = (npixout * (abs(out_bitpix) / 8)) % 2880; memset(pad, 0, 2880); fwrite(pad, 1, N, fout); } else { if (fits_pad_file(fout)) { ERROR("Failed to pad output file"); exit(-1); } if (fclose(fout)) { SYSERROR("Failed to close output file"); exit(-1); } } logverb("Done!\n"); return 0; }
static void start_application(void) { //**************************************** // start the program without using a shell //**************************************** if (arg_shell_none) { if (arg_debug) { int i; for (i = cfg.original_program_index; i < cfg.original_argc; i++) { if (cfg.original_argv[i] == NULL) break; printf("execvp argument %d: %s\n", i - cfg.original_program_index, cfg.original_argv[i]); } } if (cfg.original_program_index == 0) { fprintf(stderr, "Error: --shell=none configured, but no program specified\n"); exit(1); } if (!arg_command && !arg_quiet) printf("Child process initialized\n"); execvp(cfg.original_argv[cfg.original_program_index], &cfg.original_argv[cfg.original_program_index]); } //**************************************** // start the program using a shell //**************************************** else { // choose the shell requested by the user, or use bash as default char *sh; if (cfg.shell) sh = cfg.shell; else if (arg_zsh) sh = "/usr/bin/zsh"; else if (arg_csh) sh = "/bin/csh"; else sh = "/bin/bash"; char *arg[5]; int index = 0; arg[index++] = sh; arg[index++] = "-c"; assert(cfg.command_line); if (arg_debug) printf("Starting %s\n", cfg.command_line); if (arg_doubledash) arg[index++] = "--"; arg[index++] = cfg.command_line; arg[index] = NULL; assert(index < 5); if (arg_debug) { char *msg; if (asprintf(&msg, "sandbox %d, execvp into %s", sandbox_pid, cfg.command_line) == -1) errExit("asprintf"); logmsg(msg); free(msg); } if (arg_debug) { int i; for (i = 0; i < 5; i++) { if (arg[i] == NULL) break; printf("execvp argument %d: %s\n", i, arg[i]); } } if (!arg_command && !arg_quiet) printf("Child process initialized\n"); execvp(sh, arg); } perror("execvp"); exit(1); // it should never get here!!! }
static int select_ws(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) { DWORD milliseconds, wait, idx; WSANETWORKEVENTS wsanetevents; struct select_ws_data *data; HANDLE handle, *handles; WSAEVENT wsaevent; int error, fds; HANDLE waitevent = NULL; DWORD nfd = 0, thd = 0, wsa = 0; int ret = 0; /* check if the input value is valid */ if(nfds < 0) { errno = EINVAL; return -1; } /* check if we got descriptors, sleep in case we got none */ if(!nfds) { Sleep((timeout->tv_sec*1000)+(DWORD)(((double)timeout->tv_usec)/1000.0)); return 0; } /* create internal event to signal waiting threads */ waitevent = CreateEvent(NULL, TRUE, FALSE, NULL); if(!waitevent) { errno = ENOMEM; return -1; } /* allocate internal array for the internal data */ data = calloc(nfds, sizeof(struct select_ws_data)); if(data == NULL) { CloseHandle(waitevent); errno = ENOMEM; return -1; } /* allocate internal array for the internal event handles */ handles = calloc(nfds, sizeof(HANDLE)); if(handles == NULL) { CloseHandle(waitevent); free(data); errno = ENOMEM; return -1; } /* loop over the handles in the input descriptor sets */ for(fds = 0; fds < nfds; fds++) { long networkevents = 0; handles[nfd] = 0; if(FD_ISSET(fds, readfds)) networkevents |= FD_READ|FD_ACCEPT|FD_CLOSE; if(FD_ISSET(fds, writefds)) networkevents |= FD_WRITE|FD_CONNECT; if(FD_ISSET(fds, exceptfds)) networkevents |= FD_OOB|FD_CLOSE; /* only wait for events for which we actually care */ if(networkevents) { data[nfd].fd = curlx_sitosk(fds); if(fds == fileno(stdin)) { handle = GetStdHandle(STD_INPUT_HANDLE); handle = select_ws_wait(handle, waitevent); handles[nfd] = handle; data[thd].thread = handle; thd++; } else if(fds == fileno(stdout)) { handles[nfd] = GetStdHandle(STD_OUTPUT_HANDLE); } else if(fds == fileno(stderr)) { handles[nfd] = GetStdHandle(STD_ERROR_HANDLE); } else { wsaevent = WSACreateEvent(); if(wsaevent != WSA_INVALID_EVENT) { error = WSAEventSelect(fds, wsaevent, networkevents); if(error != SOCKET_ERROR) { handle = (HANDLE) wsaevent; handles[nfd] = handle; data[wsa].wsasock = curlx_sitosk(fds); data[wsa].wsaevent = wsaevent; wsa++; } else { curl_socket_t socket = curlx_sitosk(fds); WSACloseEvent(wsaevent); handle = (HANDLE) socket; handle = select_ws_wait(handle, waitevent); handles[nfd] = handle; data[thd].thread = handle; thd++; } } } nfd++; } } /* convert struct timeval to milliseconds */ if(timeout) { milliseconds = ((timeout->tv_sec * 1000) + (timeout->tv_usec / 1000)); } else { milliseconds = INFINITE; } /* wait for one of the internal handles to trigger */ wait = WaitForMultipleObjectsEx(nfd, handles, FALSE, milliseconds, FALSE); /* signal the event handle for the waiting threads */ SetEvent(waitevent); /* loop over the internal handles returned in the descriptors */ for(idx = 0; idx < nfd; idx++) { curl_socket_t sock = data[idx].fd; handle = handles[idx]; fds = curlx_sktosi(sock); /* check if the current internal handle was triggered */ if(wait != WAIT_FAILED && (wait - WAIT_OBJECT_0) <= idx && WaitForSingleObjectEx(handle, 0, FALSE) == WAIT_OBJECT_0) { /* first handle stdin, stdout and stderr */ if(fds == fileno(stdin)) { /* stdin is never ready for write or exceptional */ FD_CLR(sock, writefds); FD_CLR(sock, exceptfds); } else if(fds == fileno(stdout) || fds == fileno(stderr)) { /* stdout and stderr are never ready for read or exceptional */ FD_CLR(sock, readfds); FD_CLR(sock, exceptfds); } else { /* try to handle the event with the WINSOCK2 functions */ wsanetevents.lNetworkEvents = 0; error = WSAEnumNetworkEvents(fds, handle, &wsanetevents); if(error != SOCKET_ERROR) { /* remove from descriptor set if not ready for read/accept/close */ if(!(wsanetevents.lNetworkEvents & (FD_READ|FD_ACCEPT|FD_CLOSE))) FD_CLR(sock, readfds); /* remove from descriptor set if not ready for write/connect */ if(!(wsanetevents.lNetworkEvents & (FD_WRITE|FD_CONNECT))) FD_CLR(sock, writefds); /* HACK: * use exceptfds together with readfds to signal * that the connection was closed by the client. * * Reason: FD_CLOSE is only signaled once, sometimes * at the same time as FD_READ with data being available. * This means that recv/sread is not reliable to detect * that the connection is closed. */ /* remove from descriptor set if not exceptional */ if(!(wsanetevents.lNetworkEvents & (FD_OOB|FD_CLOSE))) FD_CLR(sock, exceptfds); } } /* check if the event has not been filtered using specific tests */ if(FD_ISSET(sock, readfds) || FD_ISSET(sock, writefds) || FD_ISSET(sock, exceptfds)) { ret++; } } else { /* remove from all descriptor sets since this handle did not trigger */ FD_CLR(sock, readfds); FD_CLR(sock, writefds); FD_CLR(sock, exceptfds); } } for(fds = 0; fds < nfds; fds++) { if(FD_ISSET(fds, readfds)) logmsg("select_ws: %d is readable", fds); if(FD_ISSET(fds, writefds)) logmsg("select_ws: %d is writable", fds); if(FD_ISSET(fds, exceptfds)) logmsg("select_ws: %d is excepted", fds); } for(idx = 0; idx < wsa; idx++) { WSAEventSelect(data[idx].wsasock, NULL, 0); WSACloseEvent(data[idx].wsaevent); } for(idx = 0; idx < thd; idx++) { WaitForSingleObject(data[idx].thread, INFINITE); CloseHandle(data[idx].thread); } CloseHandle(waitevent); free(handles); free(data); return ret; }
static void kbd_lmu_backlight_set(int val, int who) { int curval; int i; float fadeval; float step; struct timespec fade_step; int fd; int ret; if (kbd_bck_info.inhibit & ~KBD_INHIBIT_CFG) return; if (lmu_info.lmuaddr == 0) return; curval = kbd_backlight_get(); if (val == curval) return; if ((val < KBD_BACKLIGHT_OFF) || (val > KBD_BACKLIGHT_MAX)) return; fd = open(lmu_info.i2cdev, O_RDWR); if (fd < 0) { logmsg(LOG_ERR, "Could not open %s: %s", lmu_info.i2cdev, strerror(errno)); return; } ret = ioctl(fd, I2C_SLAVE, lmu_info.lmuaddr); if (ret < 0) { logmsg(LOG_ERR, "Could not ioctl the i2c bus: %s", strerror(errno)); close(fd); return; } if (who == KBD_AUTO) { fade_step.tv_sec = 0; fade_step.tv_nsec = (KBD_BACKLIGHT_FADE_LENGTH / KBD_BACKLIGHT_FADE_STEPS) * 1000000; fadeval = (float)curval; step = (float)(val - curval) / (float)KBD_BACKLIGHT_FADE_STEPS; for (i = 0; i < KBD_BACKLIGHT_FADE_STEPS; i++) { fadeval += step; lmu_write_kbd_value(fd, (unsigned char)fadeval); logdebug("KBD backlight value faded to %d\n", (int)fadeval); nanosleep(&fade_step, NULL); } } lmu_write_kbd_value(fd, val); close(fd); mbpdbus_send_kbd_backlight(val, kbd_bck_info.level, who); kbd_bck_info.level = val; }
/* sockfdp is a pointer to an established stream or CURL_SOCKET_BAD if sockfd is CURL_SOCKET_BAD, listendfd is a listening socket we must accept() */ static bool juggle(curl_socket_t *sockfdp, curl_socket_t listenfd, enum sockmode *mode) { struct timeval timeout; fd_set fds_read; fd_set fds_write; fd_set fds_err; curl_socket_t sockfd = CURL_SOCKET_BAD; int maxfd = -99; ssize_t rc; int error = 0; /* 'buffer' is this excessively large only to be able to support things like test 1003 which tests exceedingly large server response lines */ unsigned char buffer[17010]; char data[16]; if(got_exit_signal) { logmsg("signalled to die, exiting..."); return FALSE; } #ifdef HAVE_GETPPID /* As a last resort, quit if sockfilt process becomes orphan. Just in case parent ftpserver process has died without killing its sockfilt children */ if(getppid() <= 1) { logmsg("process becomes orphan, exiting"); return FALSE; } #endif timeout.tv_sec = 120; timeout.tv_usec = 0; FD_ZERO(&fds_read); FD_ZERO(&fds_write); FD_ZERO(&fds_err); FD_SET((curl_socket_t)fileno(stdin), &fds_read); switch(*mode) { case PASSIVE_LISTEN: /* server mode */ sockfd = listenfd; /* there's always a socket to wait for */ FD_SET(sockfd, &fds_read); maxfd = (int)sockfd; break; case PASSIVE_CONNECT: sockfd = *sockfdp; if(CURL_SOCKET_BAD == sockfd) { /* eeek, we are supposedly connected and then this cannot be -1 ! */ logmsg("socket is -1! on %s:%d", __FILE__, __LINE__); maxfd = 0; /* stdin */ } else { /* there's always a socket to wait for */ FD_SET(sockfd, &fds_read); #ifdef USE_WINSOCK FD_SET(sockfd, &fds_err); #endif maxfd = (int)sockfd; } break; case ACTIVE: sockfd = *sockfdp; /* sockfd turns CURL_SOCKET_BAD when our connection has been closed */ if(CURL_SOCKET_BAD != sockfd) { FD_SET(sockfd, &fds_read); #ifdef USE_WINSOCK FD_SET(sockfd, &fds_err); #endif maxfd = (int)sockfd; } else { logmsg("No socket to read on"); maxfd = 0; } break; case ACTIVE_DISCONNECT: logmsg("disconnected, no socket to read on"); maxfd = 0; sockfd = CURL_SOCKET_BAD; break; } /* switch(*mode) */ do { /* select() blocking behavior call on blocking descriptors please */ rc = select(maxfd + 1, &fds_read, &fds_write, &fds_err, &timeout); if(got_exit_signal) { logmsg("signalled to die, exiting..."); return FALSE; } } while((rc == -1) && ((error = errno) == EINTR)); if(rc < 0) { logmsg("select() failed with error: (%d) %s", error, strerror(error)); return FALSE; } if(rc == 0) /* timeout */ return TRUE; if(FD_ISSET(fileno(stdin), &fds_read)) { ssize_t buffer_len; /* read from stdin, commands/data to be dealt with and possibly passed on to the socket protocol: 4 letter command + LF [mandatory] 4-digit hexadecimal data length + LF [if the command takes data] data [the data being as long as set above] Commands: DATA - plain pass-through data */ if(!read_stdin(buffer, 5)) return FALSE; logmsg("Received %c%c%c%c (on stdin)", buffer[0], buffer[1], buffer[2], buffer[3]); if(!memcmp("PING", buffer, 4)) { /* send reply on stdout, just proving we are alive */ if(!write_stdout("PONG\n", 5)) return FALSE; } else if(!memcmp("PORT", buffer, 4)) { /* Question asking us what PORT number we are listening to. Replies to PORT with "IPv[num]/[port]" */ snprintf((char *)buffer, sizeof(buffer), "%s/%hu\n", ipv_inuse, port); buffer_len = (ssize_t)strlen((char *)buffer); snprintf(data, sizeof(data), "PORT\n%04zx\n", buffer_len); if(!write_stdout(data, 10)) return FALSE; if(!write_stdout(buffer, buffer_len)) return FALSE; } else if(!memcmp("QUIT", buffer, 4)) { /* just die */ logmsg("quits"); return FALSE; } else if(!memcmp("DATA", buffer, 4)) { /* data IN => data OUT */ if(!read_stdin(buffer, 5)) return FALSE; buffer[5] = '\0'; buffer_len = (ssize_t)strtol((char *)buffer, NULL, 16); if(buffer_len > (ssize_t)sizeof(buffer)) { logmsg("ERROR: Buffer size (%zu bytes) too small for data size " "(%zd bytes)", sizeof(buffer), buffer_len); return FALSE; } logmsg("> %zd bytes data, server => client", buffer_len); if(!read_stdin(buffer, buffer_len)) return FALSE; lograw(buffer, buffer_len); if(*mode == PASSIVE_LISTEN) { logmsg("*** We are disconnected!"); if(!write_stdout("DISC\n", 5)) return FALSE; } else { /* send away on the socket */ ssize_t bytes_written = swrite(sockfd, buffer, buffer_len); if(bytes_written != buffer_len) { logmsg("Not all data was sent. Bytes to send: %zd sent: %zd", buffer_len, bytes_written); } } } else if(!memcmp("DISC", buffer, 4)) { /* disconnect! */ if(!write_stdout("DISC\n", 5)) return FALSE; if(sockfd != CURL_SOCKET_BAD) { logmsg("====> Client forcibly disconnected"); sclose(sockfd); *sockfdp = CURL_SOCKET_BAD; if(*mode == PASSIVE_CONNECT) *mode = PASSIVE_LISTEN; else *mode = ACTIVE_DISCONNECT; } else logmsg("attempt to close already dead connection"); return TRUE; } } if((sockfd != CURL_SOCKET_BAD) && (FD_ISSET(sockfd, &fds_read)) ) { ssize_t nread_socket; if(*mode == PASSIVE_LISTEN) { /* there's no stream set up yet, this is an indication that there's a client connecting. */ curl_socket_t newfd = accept(sockfd, NULL, NULL); if(CURL_SOCKET_BAD == newfd) { error = SOCKERRNO; logmsg("accept(%d, NULL, NULL) failed with error: (%d) %s", sockfd, error, strerror(error)); } else { logmsg("====> Client connect"); if(!write_stdout("CNCT\n", 5)) return FALSE; *sockfdp = newfd; /* store the new socket */ *mode = PASSIVE_CONNECT; /* we have connected */ } return TRUE; } /* read from socket, pass on data to stdout */ nread_socket = sread(sockfd, buffer, sizeof(buffer)); if(nread_socket > 0) { snprintf(data, sizeof(data), "DATA\n%04zx\n", nread_socket); if(!write_stdout(data, 10)) return FALSE; if(!write_stdout(buffer, nread_socket)) return FALSE; logmsg("< %zd bytes data, client => server", nread_socket); lograw(buffer, nread_socket); } if(nread_socket <= 0 #ifdef USE_WINSOCK || FD_ISSET(sockfd, &fds_err) #endif ) { logmsg("====> Client disconnect"); if(!write_stdout("DISC\n", 5)) return FALSE; sclose(sockfd); *sockfdp = CURL_SOCKET_BAD; if(*mode == PASSIVE_CONNECT) *mode = PASSIVE_LISTEN; else *mode = ACTIVE_DISCONNECT; return TRUE; } } return TRUE; }
int plot_index_plot(const char* command, cairo_t* cairo, plot_args_t* pargs, void* baton) { plotindex_t* args = (plotindex_t*)baton; int i; double ra, dec, radius; double xyz[3]; double r2; pad_qidxes(args); plotstuff_builtin_apply(cairo, pargs); if (plotstuff_get_radec_center_and_radius(pargs, &ra, &dec, &radius)) { ERROR("Failed to get RA,Dec center and radius"); return -1; } radecdeg2xyzarr(ra, dec, xyz); r2 = deg2distsq(radius); logmsg("Field RA,Dec,radius = (%g,%g), %g deg\n", ra, dec, radius); logmsg("distsq: %g\n", r2); for (i=0; i<pl_size(args->indexes); i++) { index_t* index = pl_get(args->indexes, i); int j, N; int DQ; double px,py; if (args->stars) { // plot stars double* radecs = NULL; startree_search_for(index->starkd, xyz, r2, NULL, &radecs, NULL, &N); if (N) { assert(radecs); } logmsg("Found %i stars in range in index %s\n", N, index->indexname); for (j=0; j<N; j++) { logverb(" RA,Dec (%g,%g) -> x,y (%g,%g)\n", radecs[2*j], radecs[2*j+1], px, py); if (!plotstuff_radec2xy(pargs, radecs[j*2], radecs[j*2+1], &px, &py)) { ERROR("Failed to convert RA,Dec %g,%g to pixels\n", radecs[j*2], radecs[j*2+1]); continue; } cairoutils_draw_marker(cairo, pargs->marker, px, py, pargs->markersize); cairo_stroke(cairo); } free(radecs); } if (args->quads) { DQ = index_get_quad_dim(index); qidxfile* qidx = pl_get(args->qidxes, i); if (qidx) { int* stars; int Nstars; il* quadlist = il_new(256); // find stars in range. startree_search_for(index->starkd, xyz, r2, NULL, NULL, &stars, &Nstars); logmsg("Found %i stars in range of index %s\n", N, index->indexname); logmsg("Using qidx file.\n"); // find quads that each star is a member of. for (j=0; j<Nstars; j++) { uint32_t* quads; int Nquads; int k; if (qidxfile_get_quads(qidx, stars[j], &quads, &Nquads)) { ERROR("Failed to get quads for star %i\n", stars[j]); return -1; } for (k=0; k<Nquads; k++) il_insert_unique_ascending(quadlist, quads[k]); } for (j=0; j<il_size(quadlist); j++) { plotquad(cairo, pargs, args, index, il_get(quadlist, j), DQ); } } else { // plot quads N = index_nquads(index); for (j=0; j<N; j++) { plotquad(cairo, pargs, args, index, j, DQ); } } } } return 0; }
/*-------------------------------------------------------------------*/ int inet_socket (char* spec) { /* We need a copy of the path to overwrite a ':' with '\0' */ char buf[sizeof(((DEVBLK*)0)->filename)]; char* colon; char* node; char* service; int sd; int one = 1; struct sockaddr_in sin; logdebug("inet_socket(%s)\n", spec); memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; strcpy(buf, spec); colon = strchr(buf, ':'); if (colon) { *colon = '\0'; node = buf; service = colon + 1; } else { node = NULL; service = buf; } if (!node) sin.sin_addr.s_addr = INADDR_ANY; else { struct hostent* he = gethostbyname(node); if (!he) { logmsg (_("HHCSD011E Failed to determine IP address from %s\n"), node); return -1; } memcpy(&sin.sin_addr, he->h_addr_list[0], sizeof(sin.sin_addr)); } if (isdigit(service[0])) { sin.sin_port = htons(atoi(service)); } else { struct servent* se = getservbyname(service, "tcp"); if (!se) { logmsg (_("HHCSD012E Failed to determine port number from %s\n"), service); return -1; } sin.sin_port = se->s_port; } sd = socket (PF_INET, SOCK_STREAM, 0); if (sd == -1) { logmsg (_("HHCSD013E Error creating socket for %s: %s\n"), spec, strerror(HSO_errno)); return -1; } setsockopt (sd, SOL_SOCKET, SO_REUSEADDR, (GETSET_SOCKOPT_T*)&one, sizeof(one)); if (0 || bind (sd, (struct sockaddr*) &sin, sizeof(sin)) == -1 || listen (sd, 0) == -1 ) { logmsg (_("HHCSD014E Failed to bind or listen on socket %s: %s\n"), spec, strerror(HSO_errno)); return -1; } return sd; }
static int setup_device(struct CI* CI){ char dev[256]; snprintf(dev, 256, "/dev/%s", CI->iface); char config[256]; snprintf(config, sizeof(config), "slen=%d %s", snaplen(), dag_config); logmsg(verbose, CAPTURE, "\tdevice: %s\n", dev); logmsg(verbose, CAPTURE, "\tconfig: \"%s\"\n", config); if ( dag_mode == 0 ){ logmsg(verbose, CAPTURE, "\tPort A: RX\n"); logmsg(verbose, CAPTURE, "\tPort B: TX\n"); } else { logmsg(verbose, CAPTURE, "\tPort A: RX -> B [wiretap]\n"); logmsg(verbose, CAPTURE, "\tPort B: TX -> A [wiretap]\n"); } CI->sd = dag_open(dev); if ( CI->sd < 0 ) { int e = errno; logmsg(stderr, CAPTURE, "dag_open() on interface %s returned %d: %s\n", dev, e, strerror(e)); return 0; } #if DAGDRIVER_MAJOR < 5 if ( dag_configure(CI->sd, config) < 0 ) { int e = errno; logmsg(stderr, CAPTURE, "dag_configure() on interface %s returned %d: %s\n", dev, e, strerror(e)); return 0; } #endif #if DAGDRIVER_MAJOR >4 card_ref = NULL; root_component = NULL; card_ref = dag_config_init(dev); root_component = dag_config_get_root_component(card_ref); uint32_t count = dag_component_get_subcomponent_count_of_type(root_component,kComponentGpp); logmsg(stderr,CAPTURE, "subcomponents -> %d \n", count); dag_component_t port = NULL; port = dag_component_get_subcomponent(root_component, kComponentGpp,0); attr_uuid_t csnaplen = dag_component_get_config_attribute_uuid(port,kUint32AttributeSnaplength); logmsg(stderr,CAPTURE, "dag_card snaplen = %d bytes\n", (int)csnaplen); #endif if (!timesync_init(CI)){ logmsg(stderr,CAPTURE, "problem with timesync_init .\n"); } return 1; }
/*-------------------------------------------------------------------*/ int bind_device_ex (DEVBLK* dev, char* spec, ONCONNECT fn, void* arg ) { bind_struct* bs; int was_list_empty; if (!init_done) init_sockdev(); if (sysblk.shutdown) return 0; logdebug("bind_device (%4.4X, %s)\n", dev->devnum, spec); /* Error if device already bound */ if (dev->bs) { logmsg (_("HHCSD001E Device %4.4X already bound to socket %s\n"), dev->devnum, dev->bs->spec); return 0; /* (failure) */ } /* Create a new bind_struct entry */ bs = malloc(sizeof(bind_struct)); if (!bs) { logmsg (_("HHCSD002E bind_device malloc() failed for device %4.4X\n"), dev->devnum); return 0; /* (failure) */ } memset(bs,0,sizeof(bind_struct)); bs->fn = fn; bs->arg = arg; if (!(bs->spec = strdup(spec))) { logmsg (_("HHCSD003E bind_device strdup() failed for device %4.4X\n"), dev->devnum); free (bs); return 0; /* (failure) */ } /* Create a listening socket */ if (bs->spec[0] == '/') bs->sd = unix_socket (bs->spec); else bs->sd = inet_socket (bs->spec); if (bs->sd == -1) { /* (error message already issued) */ free( bs->spec ); free( bs ); return 0; /* (failure) */ } /* Chain device and bind_struct to each other */ dev->bs = bs; bs->dev = dev; /* Add the new entry to our list of bound devices and create the socket thread that will listen for connections (if it doesn't already exist) */ obtain_lock( &bind_lock ); was_list_empty = IsListEmpty( &bind_head ); InsertListTail( &bind_head, &bs->bind_link ); if ( was_list_empty ) { if ( create_thread( &sysblk.socktid, JOINABLE, socket_thread, NULL, "socket_thread" ) ) { logmsg( _( "HHCSD023E Cannot create socketdevice thread: errno=%d: %s\n" ), errno, strerror( errno ) ); RemoveListEntry( &bs->bind_link ); close_socket(bs->sd); free( bs->spec ); free( bs ); release_lock( &bind_lock ); return 0; /* (failure) */ } } SIGNAL_SOCKDEV_THREAD(); release_lock( &bind_lock ); logmsg (_("HHCSD004I Device %4.4X bound to socket %s\n"), dev->devnum, dev->bs->spec); return 1; /* (success) */ }
static int process_packet(struct dag_context* cap, dag_record_t* dr, unsigned char* dst, struct cap_header* head){ /** * For ethernet: * * dag record * | offset ---+ +-------- Wire length -------+ * | (do not use) | | | * v v v v * +------------+---+---+---------\/\/\----------+---+- - + * | DAG | | P | | F | * | Header | | a | Payload | C | | * | | | d | | S | * +------------+---+---+---------\/\/\----------+---+- - + * ^ ^ ^ * | | | * +------------)------------ Record length --------------+ * | (aligned) * | * Payload --------+ */ const size_t rlen = ntohs(dr->rlen); /* DAG record length (aligned) */ const size_t wlen = ntohs(dr->wlen); /* DAG wire length */ const size_t pload_len = min(rlen-dag_record_size, wlen); /* payload length */ const char* payload = ((const char *)dr) + dag_record_size; if ( dr->type == TYPE_ETH ){ payload += 2; /* skip offset and padding */ } if (dr->flags.trunc) { logmsg(stderr, CAPTURE, "Truncated record on %s d=%c, packet dropped\n", head->nic, dr->flags.iface+48); cap->base.CI->packet_count++; cap->base.CI->dropped_count++; return 0; } if (dr->flags.rxerror) { logmsg(stderr, CAPTURE, "RX error on %s d=%c, packet dropped\n", head->nic, dr->flags.iface+48); cap->base.CI->packet_count++; cap->base.CI->dropped_count++; return 0; } if (dr->flags.dserror) { logmsg(stderr, CAPTURE, "DS error (internal error) on %s d=%c, packet dropped\n", head->nic, dr->flags.iface+48); cap->base.CI->packet_count++; cap->base.CI->dropped_count++; return 0; } memcpy(dst, payload, pload_len); /* copied from /software/palDesktop/measurementpoint/src/v06/mp_fullsize (I assume it works) */ { unsigned long long int ts = dr->ts; head->ts.tv_sec=ts >> 32; ts = ((ts & 0xffffffffULL) * 1000ULL * 1000ULL * 1000UL * 4ULL); ts += (ts & 0x80000000ULL) << 1; head->ts.tv_psec = (ts >> 32); head->ts.tv_psec *= 250; // DAG counter is based on 250ps increments.. } head->len = wlen - 4; /* do not include FCS in len */ head->caplen = pload_len; /* rewrite iface to indicate direction (dag0 -> d0X where X is direction) */ head->nic[1] = head->nic[3]; head->nic[2] = dr->flags.iface + 48; head->nic[3] = 0; return head->len; }
int main(int argc, char **argv) { /* initial configuration, will be overridden by config file and command line options */ first_init = 1; running = 0; // will be set to != 0 once honeytrap set up itself /* save command line arguments */ arg_c = argc; arg_v = argv; /* the following are default values - change them in your configuration file */ daemonize = 1; // default is to daemonize #ifdef USE_PCAP_MON promisc_mode = 0; // no promisc mode pcap_offset = 0; // will be set after link type is determined #endif log_level = LOG_NOTICE; // default log level logfile_fd = STDOUT_FILENO;// default logfile, stdout will be replaced by logfile_fd u_id = 0; // root privileges per default g_id = 0; conn_timeout = 120; // 2 minutes connect timeout read_timeout = 1; // 1 second read timeout m_read_timeout = 60; // 1 minute read timeout for mirror connections read_limit = 0; // 0 means no read limit conffile_name = strdup("/etc/honeytrap/honeytrap.conf"); pidfile_name = strdup("/var/run/honeytrap.pid"); logfile_name = strdup("/var/log/honeytrap.log"); response_dir = strdup("/etc/honeytrap/responses"); plugin_dir = strdup("/etc/honeytrap/plugins"); #ifdef USE_PCAP_MON dev = NULL; // network device pointer packet_sniffer = NULL; // pcap device pointer #endif portconf_default = PORTCONF_NONE; eventlist = NULL; // list of timer-based events /* configure honeytrap */ configure(arg_c, arg_v); /* daemonize (detach from console) */ if (daemonize) do_daemonize(); /* now initialize plugins */ init_plugins(); /* create pid file */ create_pid_file(); /* create IPC pipe and queue for port infos */ if (pipe(portinfopipe) == -1) { logmsg(LOG_ERR, 0, " Error - Unable to create port info IPC pipe: %m.\n"); exit(EXIT_FAILURE); } if ((portinfoq = queue_new()) == NULL) { logmsg(LOG_ERR, 0, " Error - Unable to create port info IPC pipe: %m.\n"); exit(EXIT_FAILURE); } /* watch out for incoming connection requests */ if (start_connection_monitor() < 0) clean_exit(EXIT_SUCCESS); return(0); }
bool MTPDevice::connect_priv(int dev_no, const std::string &dev_file) { if (m_device) { logerr("Already connected.\n"); return true; } int raw_devices_cnt; LIBMTP_raw_device_t *raw_devices; // Do not output LIBMTP debug stuff StreamHelper::off(); LIBMTP_error_number_t err = LIBMTP_Detect_Raw_Devices( &raw_devices, &raw_devices_cnt); StreamHelper::on(); if (err != LIBMTP_ERROR_NONE) { switch(err) { case LIBMTP_ERROR_NO_DEVICE_ATTACHED: logerr("No raw devices found.\n"); break; case LIBMTP_ERROR_CONNECTING: logerr("There has been an error connecting. Exiting.\n"); break; case LIBMTP_ERROR_MEMORY_ALLOCATION: logerr("Encountered a Memory Allocation Error. Exiting.\n"); break; case LIBMTP_ERROR_GENERAL: logerr("General error occured. Exiting.\n"); break; case LIBMTP_ERROR_USB_LAYER: logerr("USB Layer error occured. Exiting.\n"); break; default: break; } return false; } #ifndef HAVE_LIBUSB1 if (!dev_file.empty()) { uint8_t bnum, dnum; dev_no = raw_devices_cnt; if (smtpfs_usb_devpath(dev_file, &bnum, &dnum)) for (dev_no = 0; dev_no < raw_devices_cnt; ++dev_no) if (bnum == raw_devices[dev_no].bus_location && dnum == raw_devices[dev_no].devnum) break; if (dev_no == raw_devices_cnt) { logerr("Can not open such device '", dev_file, "'.\n"); free(static_cast<void*>(raw_devices)); return false; } } #endif // !HAVE_LIBUSB1 if (dev_no < 0 || dev_no >= raw_devices_cnt) { logerr("Can not connect to device no. ", dev_no + 1, ".\n"); free(static_cast<void*>(raw_devices)); return false; } LIBMTP_raw_device_t *raw_device = &raw_devices[dev_no]; // Do not output LIBMTP debug stuff StreamHelper::off(); m_device = LIBMTP_Open_Raw_Device_Uncached(raw_device); StreamHelper::on(); free(static_cast<void*>(raw_devices)); if (!m_device) { LIBMTP_Dump_Errorstack(m_device); return false; } if (!enumStorages()) return false; // Retrieve capabilities. m_capabilities = MTPDevice::getCapabilities(*this); logmsg("Connected.\n"); return true; }
/* * if return error, the lnd_rpc_err or lnd_gss_err is set. */ static int lgssc_negotiation(struct lgss_nego_data *lnd) { struct lgss_init_res gr; gss_buffer_desc *recv_tokenp, send_token; OM_uint32 maj_stat, min_stat, ret_flags; logmsg(LL_TRACE, "start gss negotiation\n"); /* GSS context establishment loop. */ memset(&gr, 0, sizeof(gr)); recv_tokenp = GSS_C_NO_BUFFER; for (;;) { maj_stat = gss_init_sec_context(&min_stat, lnd->lnd_cred, &lnd->lnd_ctx, lnd->lnd_svc_name, lnd->lnd_mech, lnd->lnd_req_flags, 0, /* time req */ NULL, /* channel */ recv_tokenp, NULL, /* used mech */ &send_token, &ret_flags, NULL); /* time rec */ if (recv_tokenp != GSS_C_NO_BUFFER) { gss_release_buffer(&min_stat, &gr.gr_token); recv_tokenp = GSS_C_NO_BUFFER; } if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED) { lnd->lnd_gss_err = maj_stat; logmsg_gss(LL_ERR, lnd->lnd_mech, maj_stat, min_stat, "failed init context"); break; } if (send_token.length != 0) { memset(&gr, 0, sizeof(gr)); lnd->lnd_rpc_err = do_nego_rpc(lnd, &send_token, &gr); gss_release_buffer(&min_stat, &send_token); if (lnd->lnd_rpc_err) { logmsg(LL_ERR, "negotiation rpc error: %d\n", lnd->lnd_rpc_err); return -1; } if (gr.gr_major != GSS_S_COMPLETE && gr.gr_major != GSS_S_CONTINUE_NEEDED) { lnd->lnd_gss_err = gr.gr_major; logmsg(LL_ERR, "negotiation gss error %x\n", lnd->lnd_gss_err); return -1; } if (gr.gr_ctx.length != 0) { if (lnd->lnd_rmt_ctx.value) gss_release_buffer(&min_stat, &lnd->lnd_rmt_ctx); lnd->lnd_rmt_ctx = gr.gr_ctx; } if (gr.gr_token.length != 0) { if (maj_stat != GSS_S_CONTINUE_NEEDED) break; recv_tokenp = &gr.gr_token; } } /* GSS_S_COMPLETE => check gss header verifier, * usually checked in gss_validate */ if (maj_stat == GSS_S_COMPLETE) { lnd->lnd_established = 1; lnd->lnd_seq_win = gr.gr_win; break; } } /* End context negotiation loop. */ if (!lnd->lnd_established) { if (gr.gr_token.length != 0) gss_release_buffer(&min_stat, &gr.gr_token); if (lnd->lnd_gss_err == GSS_S_COMPLETE) lnd->lnd_rpc_err = -EACCES; logmsg(LL_ERR, "context negotiation failed\n"); return -1; } logmsg(LL_DEBUG, "successfully negotiated a context\n"); return 0; }
static curl_socket_t sockdaemon(curl_socket_t sock, unsigned short *listenport) { /* passive daemon style */ srvr_sockaddr_union_t listener; int flag; int rc; int totdelay = 0; int maxretr = 10; int delay = 20; int attempt = 0; int error = 0; do { attempt++; flag = 1; rc = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag)); if(rc) { error = SOCKERRNO; logmsg("setsockopt(SO_REUSEADDR) failed with error: (%d) %s", error, strerror(error)); if(maxretr) { rc = wait_ms(delay); if(rc) { /* should not happen */ error = errno; logmsg("wait_ms() failed with error: (%d) %s", error, strerror(error)); sclose(sock); return CURL_SOCKET_BAD; } if(got_exit_signal) { logmsg("signalled to die, exiting..."); sclose(sock); return CURL_SOCKET_BAD; } totdelay += delay; delay *= 2; /* double the sleep for next attempt */ } } } while(rc && maxretr--); if(rc) { logmsg("setsockopt(SO_REUSEADDR) failed %d times in %d ms. Error: (%d) %s", attempt, totdelay, error, strerror(error)); logmsg("Continuing anyway..."); } /* When the specified listener port is zero, it is actually a request to let the system choose a non-zero available port. */ #ifdef ENABLE_IPV6 if(!use_ipv6) { #endif memset(&listener.sa4, 0, sizeof(listener.sa4)); listener.sa4.sin_family = AF_INET; listener.sa4.sin_addr.s_addr = INADDR_ANY; listener.sa4.sin_port = htons(*listenport); rc = bind(sock, &listener.sa, sizeof(listener.sa4)); #ifdef ENABLE_IPV6 } else { memset(&listener.sa6, 0, sizeof(listener.sa6)); listener.sa6.sin6_family = AF_INET6; listener.sa6.sin6_addr = in6addr_any; listener.sa6.sin6_port = htons(*listenport); rc = bind(sock, &listener.sa, sizeof(listener.sa6)); } #endif /* ENABLE_IPV6 */ if(rc) { error = SOCKERRNO; logmsg("Error binding socket on port %hu: (%d) %s", *listenport, error, strerror(error)); sclose(sock); return CURL_SOCKET_BAD; } if(!*listenport) { /* The system was supposed to choose a port number, figure out which port we actually got and update the listener port value with it. */ curl_socklen_t la_size; srvr_sockaddr_union_t localaddr; #ifdef ENABLE_IPV6 if(!use_ipv6) #endif la_size = sizeof(localaddr.sa4); #ifdef ENABLE_IPV6 else la_size = sizeof(localaddr.sa6); #endif memset(&localaddr.sa, 0, (size_t)la_size); if(getsockname(sock, &localaddr.sa, &la_size) < 0) { error = SOCKERRNO; logmsg("getsockname() failed with error: (%d) %s", error, strerror(error)); sclose(sock); return CURL_SOCKET_BAD; } switch(localaddr.sa.sa_family) { case AF_INET: *listenport = ntohs(localaddr.sa4.sin_port); break; #ifdef ENABLE_IPV6 case AF_INET6: *listenport = ntohs(localaddr.sa6.sin6_port); break; #endif default: break; } if(!*listenport) { /* Real failure, listener port shall not be zero beyond this point. */ logmsg("Apparently getsockname() succeeded, with listener port zero."); logmsg("A valid reason for this failure is a binary built without"); logmsg("proper network library linkage. This might not be the only"); logmsg("reason, but double check it before anything else."); sclose(sock); return CURL_SOCKET_BAD; } } /* bindonly option forces no listening */ if(bind_only) { logmsg("instructed to bind port without listening"); return sock; } /* start accepting connections */ rc = listen(sock, 5); if(0 != rc) { error = SOCKERRNO; logmsg("listen(%d, 5) failed with error: (%d) %s", sock, error, strerror(error)); sclose(sock); return CURL_SOCKET_BAD; } return sock; }
int main(int argc, char *argv[]) { struct keyring_upcall_param uparam; key_serial_t keyid; key_serial_t sring; key_serial_t inst_keyring; pid_t child; struct lgss_mech_type *mech; struct lgss_cred *cred; set_log_level(); logmsg(LL_TRACE, "start parsing parameters\n"); /* * parse & sanity check upcall parameters * expected to be called with: * [1]: operation * [2]: key ID * [3]: key type * [4]: key description * [5]: call out info * [6]: UID * [7]: GID * [8]: thread keyring * [9]: process keyring * [10]: session keyring */ if (argc != 10 + 1) { logmsg(LL_ERR, "invalid parameter number %d\n", argc); return 1; } logmsg(LL_INFO, "key %s, desc %s, ugid %s:%s, sring %s, coinfo %s\n", argv[2], argv[4], argv[6], argv[7], argv[10], argv[5]); memset(&uparam, 0, sizeof(uparam)); if (strcmp(argv[1], "create") != 0) { logmsg(LL_ERR, "invalid OP %s\n", argv[1]); return 1; } if (sscanf(argv[2], "%d", &keyid) != 1) { logmsg(LL_ERR, "can't extract KeyID: %s\n", argv[2]); return 1; } if (sscanf(argv[6], "%d", &uparam.kup_fsuid) != 1) { logmsg(LL_ERR, "can't extract UID: %s\n", argv[6]); return 1; } if (sscanf(argv[7], "%d", &uparam.kup_fsgid) != 1) { logmsg(LL_ERR, "can't extract GID: %s\n", argv[7]); return 1; } if (sscanf(argv[10], "%d", &sring) != 1) { logmsg(LL_ERR, "can't extract session keyring: %s\n", argv[10]); return 1; } if (parse_callout_info(argv[5], &uparam)) { logmsg(LL_ERR, "can't extract callout info: %s\n", argv[5]); return 1; } logmsg(LL_TRACE, "parsing parameters OK\n"); /* * prepare a cred */ mech = lgss_name2mech(uparam.kup_mech); if (mech == NULL) { logmsg(LL_ERR, "key %08x: unsupported mech: %s\n", keyid, uparam.kup_mech); return 1; } if (lgss_mech_initialize(mech)) { logmsg(LL_ERR, "key %08x: can't initialize mech %s\n", keyid, mech->lmt_name); return 1; } cred = lgss_create_cred(mech); if (cred == NULL) { logmsg(LL_ERR, "key %08x: can't create a new %s cred\n", keyid, mech->lmt_name); return 1; } cred->lc_uid = uparam.kup_uid; cred->lc_root_flags |= uparam.kup_is_root ? LGSS_ROOT_CRED_ROOT : 0; cred->lc_root_flags |= uparam.kup_is_mdt ? LGSS_ROOT_CRED_MDT : 0; cred->lc_root_flags |= uparam.kup_is_ost ? LGSS_ROOT_CRED_OST : 0; cred->lc_tgt_nid = uparam.kup_nid; cred->lc_tgt_svc = uparam.kup_svc; if (lgss_prepare_cred(cred)) { logmsg(LL_ERR, "key %08x: failed to prepare credentials " "for user %d\n", keyid, uparam.kup_uid); return 1; } /* pre initialize the key. note the keyring linked to is actually of the * original requesting process, not _this_ upcall process. if it's for * root user, don't link to any keyrings because we want fully control * on it, and share it among all root sessions; otherswise link to * session keyring. */ if (cred->lc_root_flags != 0) inst_keyring = 0; else inst_keyring = KEY_SPEC_SESSION_KEYRING; if (keyctl_instantiate(keyid, NULL, 0, inst_keyring)) { logmsg(LL_ERR, "instantiate key %08x: %s\n", keyid, strerror(errno)); return 1; } logmsg(LL_TRACE, "instantiated kernel key %08x\n", keyid); /* * fork a child to do the real gss negotiation */ child = fork(); if (child == -1) { logmsg(LL_ERR, "key %08x: can't create child: %s\n", keyid, strerror(errno)); return 1; } else if (child == 0) { return lgssc_kr_negotiate(keyid, cred, &uparam); } logmsg(LL_TRACE, "forked child %d\n", child); return 0; }
int main(int argc, char *argv[]) { srvr_sockaddr_union_t me; curl_socket_t sock = CURL_SOCKET_BAD; curl_socket_t msgsock = CURL_SOCKET_BAD; int wrotepidfile = 0; const char *pidname = ".sockfilt.pid"; bool juggle_again; int rc; int error; int arg = 1; enum sockmode mode = PASSIVE_LISTEN; /* default */ const char *addr = NULL; while(argc>arg) { if(!strcmp("--version", argv[arg])) { printf("sockfilt IPv4%s\n", #ifdef ENABLE_IPV6 "/IPv6" #else "" #endif ); return 0; } else if(!strcmp("--verbose", argv[arg])) { verbose = TRUE; arg++; } else if(!strcmp("--pidfile", argv[arg])) { arg++; if(argc>arg) pidname = argv[arg++]; } else if(!strcmp("--logfile", argv[arg])) { arg++; if(argc>arg) serverlogfile = argv[arg++]; } else if(!strcmp("--ipv6", argv[arg])) { #ifdef ENABLE_IPV6 ipv_inuse = "IPv6"; use_ipv6 = TRUE; #endif arg++; } else if(!strcmp("--ipv4", argv[arg])) { /* for completeness, we support this option as well */ #ifdef ENABLE_IPV6 ipv_inuse = "IPv4"; use_ipv6 = FALSE; #endif arg++; } else if(!strcmp("--bindonly", argv[arg])) { bind_only = TRUE; arg++; } else if(!strcmp("--port", argv[arg])) { arg++; if(argc>arg) { char *endptr; unsigned long ulnum = strtoul(argv[arg], &endptr, 10); if((endptr != argv[arg] + strlen(argv[arg])) || ((ulnum != 0UL) && ((ulnum < 1025UL) || (ulnum > 65535UL)))) { fprintf(stderr, "sockfilt: invalid --port argument (%s)\n", argv[arg]); return 0; } port = curlx_ultous(ulnum); arg++; } } else if(!strcmp("--connect", argv[arg])) { /* Asked to actively connect to the specified local port instead of doing a passive server-style listening. */ arg++; if(argc>arg) { char *endptr; unsigned long ulnum = strtoul(argv[arg], &endptr, 10); if((endptr != argv[arg] + strlen(argv[arg])) || (ulnum < 1025UL) || (ulnum > 65535UL)) { fprintf(stderr, "sockfilt: invalid --connect argument (%s)\n", argv[arg]); return 0; } connectport = curlx_ultous(ulnum); arg++; } } else if(!strcmp("--addr", argv[arg])) { /* Set an IP address to use with --connect; otherwise use localhost */ arg++; if(argc>arg) { addr = argv[arg]; arg++; } } else { puts("Usage: sockfilt [option]\n" " --version\n" " --verbose\n" " --logfile [file]\n" " --pidfile [file]\n" " --ipv4\n" " --ipv6\n" " --bindonly\n" " --port [port]\n" " --connect [port]\n" " --addr [address]"); return 0; } } #ifdef WIN32 win32_init(); atexit(win32_cleanup); setmode(fileno(stdin), O_BINARY); setmode(fileno(stdout), O_BINARY); setmode(fileno(stderr), O_BINARY); #endif install_signal_handlers(); #ifdef ENABLE_IPV6 if(!use_ipv6) #endif sock = socket(AF_INET, SOCK_STREAM, 0); #ifdef ENABLE_IPV6 else sock = socket(AF_INET6, SOCK_STREAM, 0); #endif if(CURL_SOCKET_BAD == sock) { error = SOCKERRNO; logmsg("Error creating socket: (%d) %s", error, strerror(error)); write_stdout("FAIL\n", 5); goto sockfilt_cleanup; } if(connectport) { /* Active mode, we should connect to the given port number */ mode = ACTIVE; #ifdef ENABLE_IPV6 if(!use_ipv6) { #endif memset(&me.sa4, 0, sizeof(me.sa4)); me.sa4.sin_family = AF_INET; me.sa4.sin_port = htons(connectport); me.sa4.sin_addr.s_addr = INADDR_ANY; if(!addr) addr = "127.0.0.1"; Curl_inet_pton(AF_INET, addr, &me.sa4.sin_addr); rc = connect(sock, &me.sa, sizeof(me.sa4)); #ifdef ENABLE_IPV6 } else { memset(&me.sa6, 0, sizeof(me.sa6)); me.sa6.sin6_family = AF_INET6; me.sa6.sin6_port = htons(connectport); if(!addr) addr = "::1"; Curl_inet_pton(AF_INET6, addr, &me.sa6.sin6_addr); rc = connect(sock, &me.sa, sizeof(me.sa6)); } #endif /* ENABLE_IPV6 */ if(rc) { error = SOCKERRNO; logmsg("Error connecting to port %hu: (%d) %s", connectport, error, strerror(error)); write_stdout("FAIL\n", 5); goto sockfilt_cleanup; } logmsg("====> Client connect"); msgsock = sock; /* use this as stream */ } else { /* passive daemon style */ sock = sockdaemon(sock, &port); if(CURL_SOCKET_BAD == sock) { write_stdout("FAIL\n", 5); goto sockfilt_cleanup; } msgsock = CURL_SOCKET_BAD; /* no stream socket yet */ } logmsg("Running %s version", ipv_inuse); if(connectport) logmsg("Connected to port %hu", connectport); else if(bind_only) logmsg("Bound without listening on port %hu", port); else logmsg("Listening on port %hu", port); wrotepidfile = write_pidfile(pidname); if(!wrotepidfile) { write_stdout("FAIL\n", 5); goto sockfilt_cleanup; } do { juggle_again = juggle(&msgsock, sock, &mode); } while(juggle_again); sockfilt_cleanup: if((msgsock != sock) && (msgsock != CURL_SOCKET_BAD)) sclose(msgsock); if(sock != CURL_SOCKET_BAD) sclose(sock); if(wrotepidfile) unlink(pidname); restore_signal_handlers(); if(got_exit_signal) { logmsg("============> sockfilt exits with signal (%d)", exit_signal); /* * To properly set the return status of the process we * must raise the same signal SIGINT or SIGTERM that we * caught and let the old handler take care of it. */ raise(exit_signal); } logmsg("============> sockfilt quits"); return 0; }
int append_domainContext(__nis_table_mapping_t **table_map, char *DomainLabel, char *Domain) { __nis_table_mapping_t *tmp_map = *table_map; char *lasts; char *tmp_dbId = NULL; char *id = NULL; int domain_specific = 0; char *myself = "append_domainContext"; if (!DomainLabel || !Domain || !tmp_map) return (-1); if (tmp_map->dbId == NULL || tmp_map->objName == NULL) { p_error = parse_bad_map_error; return (-1); } tmp_dbId = s_strndup(tmp_map->dbId, strlen(tmp_map->dbId)); if (!tmp_dbId) return (-1); if (strchr(tmp_map->dbId, COMMA_CHAR)) { domain_specific = 1; id = (char *)strtok_r(tmp_dbId, COMMA_STRING, &lasts); if (id) id = (char *)strtok_r(NULL, COMMA_STRING, &lasts); else { free(tmp_dbId); return (-1); } if (!id) { free(tmp_dbId); return (-1); } if (strcasecmp(id, DomainLabel)) { free(tmp_dbId); return (0); } } else { if (getfullmapname(&tmp_map->dbId, DomainLabel)) { free(tmp_dbId); return (-1); } append_dot(&tmp_map->dbId); } if (tmp_dbId) free(tmp_dbId); tmp_dbId = NULL; if (getfullmapname(&tmp_map->objName, DomainLabel)) return (-1); append_dot(&tmp_map->objName); /* * If domain specific mapping doesn't have objectDN, * then don't touch. Most probably, pass for the generic mapping * will handle this by coping over it's own objectDN */ if (domain_specific && tmp_map->objectDN == NULL) return (0); if (tmp_map->objectDN == NULL) { /* Allocate memory to objectDN */ tmp_map->objectDN = (__nis_object_dn_t *) s_calloc(1, sizeof (__nis_object_dn_t)); if (tmp_map->objectDN == NULL) { logmsg(MSG_NOMEM, LOG_ERR, "%s: Cannot allocate memory for objectDN", myself); return (2); } tmp_map->objectDN->read.base = NULL; tmp_map->objectDN->write.base = NULL; tmp_map->objectDN->read.attrs = NULL; tmp_map->objectDN->write.attrs = NULL; tmp_map->objectDN->read.scope = LDAP_SCOPE_ONELEVEL; tmp_map->objectDN->write.scope = LDAP_SCOPE_UNKNOWN; } if (!make_fqdn(tmp_map->objectDN, Domain)) return (-1); if (tmp_map->objectDN->write.base) { if (!make_full_dn(&tmp_map->objectDN->write.base, Domain)) return (-1); } return (0); }
void showmsgwnd(unsigned int param) { logmsg("showmsgwnd"); if (db_get_b(NULL,THIS_MODULE, "showMessageWindow", DEFAULT_SHOWMSGWIN)) CallService(MS_MSG_SENDMESSAGET, (WPARAM)param, 0); }