Beispiel #1
1
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;
}
Beispiel #2
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);
}
Beispiel #4
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;
}
Beispiel #5
0
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, &param, 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;
}
Beispiel #6
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) */
}
Beispiel #7
0
/*-------------------------------------------------------------------*/
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);
}
Beispiel #8
0
/* 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);
}
Beispiel #9
0
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;
}
Beispiel #10
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;
}
Beispiel #11
0
/*
  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;
}
Beispiel #12
0
//===============
// 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;
}
Beispiel #13
0
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;
}
Beispiel #14
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!!!
}
Beispiel #15
0
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;
}
Beispiel #16
0
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;
}
Beispiel #17
0
/*
  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;
}
Beispiel #18
0
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;
}
Beispiel #19
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;
}
Beispiel #20
0
Datei: dag.c Projekt: DPMI/mp
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;
}
Beispiel #21
0
/*-------------------------------------------------------------------*/
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) */
}
Beispiel #22
0
Datei: dag.c Projekt: DPMI/mp
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;
}
Beispiel #23
0
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;
}
Beispiel #25
0
/*
 * 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;
}
Beispiel #26
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;
}
Beispiel #27
0
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;
}
Beispiel #28
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);
}
Beispiel #30
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);
}