コード例 #1
0
ファイル: install.c プロジェクト: Barrell/wine
/***********************************************************************
 *      LaunchINFSectionExW (ADVPACK.@)
 *
 * Installs an INF section with BACKUP/ROLLBACK capabilities.
 *
 * PARAMS
 *   hWnd    [I] Handle to parent window, NULL for desktop.
 *   hInst   [I] Instance of the process.
 *   cmdline [I] Contains parameters in the order INF,section,CAB,flags,reboot.
 *   show    [I] How the window should be shown.
 *
 * RETURNS
 *  Success: ADV_SUCCESS.
 *  Failure: ADV_FAILURE.
 *
 * NOTES
 *  INF - Filename of the INF to launch.
 *  section - INF section to install.
 *  flags - see advpub.h.
 *  reboot - smart reboot behavior
 *    'A' Always reboot.
 *    'I' Reboot if needed (default).
 *    'N' No reboot.
 *
 * BUGS
 *  Doesn't handle the reboot flag.
 */
HRESULT WINAPI LaunchINFSectionExW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
{
    LPWSTR cmdline_copy, cmdline_ptr;
    LPWSTR flags, ptr;
    CABINFOW cabinfo;
    HRESULT hr;

    TRACE("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_w(cmdline), show);

    if (!cmdline)
        return ADV_FAILURE;

    cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
    cmdline_ptr = cmdline_copy;
    lstrcpyW(cmdline_copy, cmdline);

    cabinfo.pszInf = get_parameter(&cmdline_ptr, ',', TRUE);
    cabinfo.pszSection = get_parameter(&cmdline_ptr, ',', TRUE);
    cabinfo.pszCab = get_parameter(&cmdline_ptr, ',', TRUE);
    *cabinfo.szSrcPath = '\0';

    flags = get_parameter(&cmdline_ptr, ',', TRUE);
    if (flags)
        cabinfo.dwFlags = atolW(flags);

    if (!is_full_path(cabinfo.pszCab) && !is_full_path(cabinfo.pszInf))
    {
        HeapFree(GetProcessHeap(), 0, cmdline_copy);
        return E_INVALIDARG;
    }

    /* get the source path from the cab filename */
    if (cabinfo.pszCab && *cabinfo.pszCab)
    {
        if (!is_full_path(cabinfo.pszCab))
            lstrcpyW(cabinfo.szSrcPath, cabinfo.pszInf);
        else
            lstrcpyW(cabinfo.szSrcPath, cabinfo.pszCab);

        ptr = strrchrW(cabinfo.szSrcPath, '\\');
        *(++ptr) = '\0';
    }

    hr = ExecuteCabW(hWnd, &cabinfo, NULL);
    HeapFree(GetProcessHeap(), 0, cmdline_copy);
    return SUCCEEDED(hr) ? ADV_SUCCESS : ADV_FAILURE;
}
コード例 #2
0
ファイル: parse_at.c プロジェクト: bayucan/pbspro
/** @fn int parse_at_list(char *list, int use_count, int abs_path)
 * @brief	parse a comma-separated list of name[@host] items
 *
 * @param[in]	list
 * @param[out]	use_count	if true, make sure no host is repeated
 *				in the list, and host is defaulted only
 *				once
 * @param[out]	abs_path	if true, make sure the item appears to
 *				begin with an absolute path name
 *
 * @return	int
 * @retval	1	parsing failure
 * @retval	0	success

 * @par MT-Safe:	no
 * @par Side Effects:
 *	exits with return code 1 on memory allocation failure
 */
int
parse_at_list(char *list, int use_count, int abs_path)
{
	char *b, *c, *s, *list_dup;
	int rc = 0;
	char user[MAXPATHLEN+1];
	char host[PBS_MAXSERVERNAME];
	struct hostlist *ph, *nh, *hostlist = NULL;

	if ((list == NULL) || (*list == '\0'))
		return 1;

#ifdef WIN32
	back2forward_slash(list);        /* "\" translate to "/" for path */
#endif

	if ((list_dup = strdup(list)) == NULL) {
		fprintf(stderr, "Out of memory.\n");
		return 1;
	}

	for (c = list_dup; *c != '\0'; rc = 0) {
		rc = 1;

		/* Drop leading white space */
		while (isspace(*c))
			c++;

		/* If requested, is this an absolute path */
		if (abs_path && !is_full_path(c))
			break;

		/* Find the next comma */
		for (s = c; *c && *c != ','; c++)
			;

		/* Drop any trailing blanks */
		for (b = c - 1; (b >= list_dup) && isspace(*b); b--)
			*b = '\0';

		/* Make sure the list does not end with a comma */
		if (*c == ',') {
			*c++ = '\0';
			if (*c == '\0')
				break;
		}

		/* Parse the individual list item */
		if (parse_at_item(s, user, host))
			break;

		/* The user part must be given */
		if (*user == '\0')
			break;

		/* If requested, make sure the host name is not repeated */
		if (use_count) {
			ph = hostlist;
			while (ph) {
				if (strcmp(ph->host, host) == 0)
					goto duplicate;
				ph = ph->next;
			}
			nh = (struct hostlist *) malloc(sizeof(struct hostlist));
			if (nh == NULL) {
				fprintf(stderr, "Out of memory\n");
				return 1;
			}
			nh->next = hostlist;
			strcpy(nh->host, host);
			hostlist = nh;
		}
	}
duplicate:

	/* Release memory for hostlist and argument list */
	ph = hostlist;
	while (ph) {
		nh = ph->next;
		free(ph);
		ph = nh;
	}
	free(list_dup);

	return rc;
}
コード例 #3
0
ファイル: appsearch.c プロジェクト: wine-mirror/wine
static UINT search_directory( MSIPACKAGE *package, MSISIGNATURE *sig, const WCHAR *path, int depth, WCHAR **appValue )
{
    UINT rc;
    DWORD attr;
    LPWSTR val = NULL;

    TRACE("%p, %p, %s, %d, %p\n", package, sig, debugstr_w(path), depth, appValue);

    if (is_full_path( path ))
    {
        if (sig->File)
            rc = recurse_search_directory( package, &val, sig, path, depth );
        else
        {
            /* Recursively searching a directory makes no sense when the
             * directory to search is the thing you're trying to find.
             */
            rc = check_directory( package, path, &val );
        }
    }
    else
    {
        WCHAR pathWithDrive[MAX_PATH] = { 'C',':','\\',0 };
        DWORD drives = GetLogicalDrives();
        int i;

        rc = ERROR_SUCCESS;
        for (i = 0; rc == ERROR_SUCCESS && !val && i < 26; i++)
        {
            if (!(drives & (1 << i)))
                continue;

            pathWithDrive[0] = 'A' + i;
            if (GetDriveTypeW(pathWithDrive) != DRIVE_FIXED)
                continue;

            lstrcpynW(pathWithDrive + 3, path, ARRAY_SIZE(pathWithDrive) - 3);

            if (sig->File)
                rc = recurse_search_directory( package, &val, sig, pathWithDrive, depth );
            else
                rc = check_directory( package, pathWithDrive, &val );
        }
    }

    attr = msi_get_file_attributes( package, val );
    if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY) &&
        val && val[lstrlenW(val) - 1] != '\\')
    {
        val = msi_realloc(val, (lstrlenW(val) + 2) * sizeof(WCHAR));
        if (!val)
            rc = ERROR_OUTOFMEMORY;
        else
            PathAddBackslashW(val);
    }

    *appValue = val;

    TRACE("returning %d\n", rc);
    return rc;
}
コード例 #4
0
ファイル: lifl.c プロジェクト: binaryf/LIFL
void  read_cfg(const char* file)
{
    memset(&conf,0,sizeof(conf));
    FILE *fp;
    fp=fopen(file,"r");
    if(!fp)
    {
        fprintf(stderr,"Can not read config file : %s\n",file);
        exit(EXIT_FAILURE);
    }

    char *line=NULL;
    size_t len=0;

    char port[6];
    char uid[10];
    char size[10];

    memset(port,0,6);
    memset(uid,0,10);
    memset(size,0,10);
    
    while(getline(&line,&len,fp)!=-1)
    {
        get_cfg_str(line,conf.hostname,                 "hostname=",256);
        get_cfg_str(line,conf.tagname,                  "tagname=",64);
        get_cfg_str(line,conf.mountpoint,               "mountpoint=",1024);

        get_cfg_val(line,&conf.allow_other,             "allow_other=on");
        get_cfg_val(line,&conf.default_permissions,     "default_permissions=on");
        get_cfg_val(line,&conf.nonempty,                "nonempty=on");

        get_cfg_str(line,conf.db_host,                  "db_host=",256);
        get_cfg_str(line,port,                          "db_port=",6);
        get_cfg_str(line,conf.db_database,              "db_database=",64);
        get_cfg_str(line,conf.db_username,              "db_username="******"db_password="******"db_table=",64);
        get_cfg_str(line,conf.db_dump_table,            "db_dump_table=",64);
        get_cfg_str(line,conf.db_error_table,           "db_error_table=",64);

        get_cfg_val(line,&conf.enable_error_messages,   "enable_error_messages=on");
        get_cfg_val(line,&conf.enable_write_dump,       "enable_write_dump=on");

        get_cfg_str(line,uid,                           "write_dump_effective_uid=",10);
        get_cfg_str(line,size,                          "write_dump_size_less_than=",10);
        get_cfg_str(line,conf.dump_cmd,                 "write_dump_cmd=",1024);

        get_cfg_val(line,&conf.syscall_getattr,         "syscall_getattr=on");
        get_cfg_val(line,&conf.syscall_access,          "syscall_access=on");
        get_cfg_val(line,&conf.syscall_readlink,        "syscall_readlink=on");
        get_cfg_val(line,&conf.syscall_readdir,         "syscall_readdir=on");
        get_cfg_val(line,&conf.syscall_mknod,           "syscall_mknod=on");
        get_cfg_val(line,&conf.syscall_mkdir,           "syscall_mkdir=on");
        get_cfg_val(line,&conf.syscall_unlink,          "syscall_unlink=on");
        get_cfg_val(line,&conf.syscall_rmdir,           "syscall_rmdir=on");
        get_cfg_val(line,&conf.syscall_symlink,         "syscall_symlink=on");
        get_cfg_val(line,&conf.syscall_rename,          "syscall_rename=on");
        get_cfg_val(line,&conf.syscall_link,            "syscall_link=on");
        get_cfg_val(line,&conf.syscall_chmod,           "syscall_chmod=on");
        get_cfg_val(line,&conf.syscall_chown,           "syscall_chown=on");
        get_cfg_val(line,&conf.syscall_truncate,        "syscall_truncate=on");
        
        #ifdef HAVE_UTIMENSAT
        get_cfg_val(line,&conf.syscall_utimens,         "syscall_utimens=on");
        #endif
        
        get_cfg_val(line,&conf.syscall_open,            "syscall_open=on");
        get_cfg_val(line,&conf.syscall_read,            "syscall_read=on");
        get_cfg_val(line,&conf.syscall_write,           "syscall_write=on");
        get_cfg_val(line,&conf.syscall_statfs,          "syscall_statfs=on");
        
        #ifdef HAVE_POSIX_FALLOCATE
        get_cfg_val(line,&conf.syscall_fallocate,       "syscall_fallocate=on");
        #endif
        
        #ifdef HAVE_SETXATTR
        get_cfg_val(line,&conf.syscall_setxattr,        "syscall_setxattr=on");
        get_cfg_val(line,&conf.syscall_getxattr,        "syscall_getxattr=on");
        get_cfg_val(line,&conf.syscall_listxattr,       "syscall_listxattr=on");
        get_cfg_val(line,&conf.syscall_removexattr,     "syscall_removexattr=on");
        #endif
        
        get_cfg_val(line,&conf.log_username,            "log_username=on");
        get_cfg_val(line,&conf.log_groupname,           "log_groupname=on");
        get_cfg_val(line,&conf.log_tty,                 "log_tty=on");
        get_cfg_val(line,&conf.log_login_time,          "log_login_time=on");
        get_cfg_val(line,&conf.log_remote_host,         "log_remote_host=on");

        get_cfg_val(line,&conf.log_cmd,                 "log_cmd=on");
        get_cfg_val(line,&conf.log_args,                "log_args=on");
        get_cfg_val(line,&conf.log_ppid,                "log_ppid=on");
        get_cfg_val(line,&conf.log_ppid_cmd,            "log_ppid_cmd=on");
    }
    
    fclose(fp);
    free(line);

    if(!is_str(conf.hostname))
    {
        if(gethostname(conf.hostname,256)==-1) memset(conf.hostname,0,256);   
    }
    if(sscanf(port,"%i",&conf.db_port)==0)
    {
        fprintf(stderr,"You must provide a port number.\n");
        exit(EXIT_FAILURE);
    }
    if(conf.enable_write_dump)
    {
        if(is_str(uid))
        {
            if(sscanf(uid,"%i",&conf.dump_uid)==0)
            {
                fprintf(stderr,"User id must be an integer value.\n");
                exit(EXIT_FAILURE);
            }
        }
        if(is_str(size))
        {
            if(sscanf(size,"%i",&conf.dump_size)==0)
            {
                fprintf(stderr,"Size limit must be an integer value.\n");
                exit(EXIT_FAILURE);
            }
        }
    }
    if(!is_full_path(conf.mountpoint))
    {
        fprintf(stderr,"Use full path for mountpoint.\n");
        fprintf(stderr,"Mountpoint '%s' is not valid.\n",conf.mountpoint);
        exit(EXIT_FAILURE);
    }
}