Exemplo n.º 1
0
void fix_java_result(const char *stdout_file, const char *stderr_file) {
    int comp_res = execute_cmd("/bin/grep -q 'java.lang.OutOfMemoryError' %s", stderr_file);
    if (!comp_res) {
        oj_solution.result = OJ_MLE;
        oj_solution.memory_usage = oj_solution.memory_limit * STD_KB;
        return;
    }

    comp_res = execute_cmd("/bin/grep -q 'java.lang.OutOfMemoryError' %s", stdout_file);
    if (!comp_res) {
        oj_solution.result = OJ_MLE;
        oj_solution.memory_usage = oj_solution.memory_limit * STD_KB;
        return;
    }

    comp_res = execute_cmd("/bin/grep -q 'Exception' %s", stderr_file);
    if (!comp_res) {
        oj_solution.result = OJ_RE;
        return;
    }

    comp_res = execute_cmd("/bin/grep -q 'Could not create' %s", stderr_file);
    if (!comp_res) {
        oj_solution.result = OJ_RE;
        return;
    }
}
Exemplo n.º 2
0
int fix_java_mis_judge(char *work_dir, int & ACflg, int & topmemory,
		int mem_lmt) {
	int comp_res = OJ_AC;
	if (DEBUG)
		execute_cmd("cat %s/error.out", work_dir);
	comp_res = execute_cmd("grep 'java.lang.OutOfMemoryError'  %s/error.out",
			work_dir);

	if (!comp_res) {
		printf("JVM need more Memory!");
		ACflg = OJ_ML;
		topmemory = mem_lmt * STD_MB;
	}
	comp_res = execute_cmd("grep 'java.lang.OutOfMemoryError'  %s/user.out",
			work_dir);

	if (!comp_res) {
		printf("JVM need more Memory or Threads!");
		ACflg = OJ_ML;
		topmemory = mem_lmt * STD_MB;
	}
	comp_res = execute_cmd("grep 'Could not create'  %s/error.out", work_dir);

	if (!comp_res) {
		printf("jvm need more resource,tweak -Xmx Settings");
		ACflg = OJ_RE;
		//topmemory=0;
	}
	return comp_res;
}
Exemplo n.º 3
0
void copy_python_runtime(char * work_dir) {

	copy_shell_runtime(work_dir);
	execute_cmd("mkdir %s/usr", work_dir);
	execute_cmd("mkdir %s/usr/lib", work_dir);
	execute_cmd("cp /usr/bin/python* %s/", work_dir);

}
/*
    Build Dir to run exec
*/
void run_judge_clinet_mkdir(int solution_id){

    execute_cmd("mkdir %d -m 777", solution_id);

    execute_cmd("mkdir %d/%s -m 777", solution_id,  problem.my_out_path.c_str());

    execute_cmd("mkdir %d/%s -m 777", solution_id,  problem.my_result_path.c_str());

}
Exemplo n.º 5
0
void copy_ruby_runtime(char * work_dir) {

	copy_shell_runtime(work_dir);
	execute_cmd("mkdir %s/usr", work_dir);
	execute_cmd("mkdir %s/usr/lib", work_dir);
	execute_cmd("cp /usr/lib/libruby* %s/usr/lib/", work_dir);
	execute_cmd("cp /usr/bin/ruby* %s/", work_dir);

}
Exemplo n.º 6
0
/*
 * __mount(): wrapper around the mount() system call which also
 * sets the underlying block device to read-only if the mount is read-only.
 * See "man 2 mount" for return values.
 */
static int __mount(const char *source, const char *target, const struct fstab_rec *rec, int encryptable)
{
    unsigned long mountflags = rec->flags;
    int ret;
    int save_errno;

    /* We need this because sometimes we have legacy symlinks
     * that are lingering around and need cleaning up.
     */
    struct stat info;
    if (!lstat(target, &info))
        if ((info.st_mode & S_IFMT) == S_IFLNK)
            unlink(target);
    mkdir(target, 0755);

    NOTICE("%s: target='%s, encryptable=%d \n", __FUNCTION__, target, encryptable);

    if(encryptable == FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED && (!strcmp(target, PROTECT_1_MNT_POINT) || !strcmp(target, PROTECT_2_MNT_POINT)) ) {
         NOTICE("encryptable is FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED. Need to mount '%s' as tmpfs\n", target);
         if ((ret = fs_mgr_do_tmpfs_mount((char *)target))) {
             ERROR("Mount '%s' to tmpfs fail. \n", target);
         }
         else {
             NOTICE("Try to copy modem nvram from emmc to the tmpfs of '%s'\n", target);
             char tmp_mnt_point[256];

             snprintf(tmp_mnt_point, sizeof(tmp_mnt_point),  "/mnt%s", target);
             char *mkdir_argv[] = {"/system/bin/mkdir", tmp_mnt_point};
             execute_cmd(mkdir_argv, ARRAY_SIZE(mkdir_argv));

             if (!access(tmp_mnt_point, F_OK) && (ret = mount(source, tmp_mnt_point, rec->fs_type, mountflags, rec->fs_options))) {
                 ERROR("Fail: mount '%s', errno=%d \n", tmp_mnt_point, errno);
             }
             else {
                char *cp_argv[] = {"/system/bin/cp", "-Rp", tmp_mnt_point, "/"};
                execute_cmd(cp_argv, ARRAY_SIZE(cp_argv));
            
                char *umount_argv[] = {"/system/bin/umount", tmp_mnt_point};
                if(!execute_cmd(umount_argv, ARRAY_SIZE(umount_argv))) {
                    char *rm_argv[] = {"/system/bin/rm", "-rf", tmp_mnt_point};
                    execute_cmd(rm_argv, ARRAY_SIZE(rm_argv));
                }                
             }
         }
    }
    else {
        ret = mount(source, target, rec->fs_type, mountflags, rec->fs_options);
        save_errno = errno;
        INFO("%s(source=%s,target=%s,type=%s)=%d\n", __func__, source, target, rec->fs_type, ret);
        if ((ret == 0) && (mountflags & MS_RDONLY) != 0) {
            fs_set_blk_ro(source);
        }
        errno = save_errno;
    }
    return ret;
}
Exemplo n.º 7
0
void copy_php_runtime(char * work_dir) {

	copy_shell_runtime(work_dir);
	execute_cmd("mkdir %s/usr", work_dir);
	execute_cmd("mkdir %s/usr/lib", work_dir);
	execute_cmd("cp /usr/lib/libedit* %s/usr/lib/", work_dir);
	execute_cmd("cp /usr/lib/libdb* %s/usr/lib/", work_dir);
	execute_cmd("cp /usr/lib/libgssapi_krb5* %s/usr/lib/", work_dir);
	execute_cmd("cp /usr/lib/libkrb5* %s/usr/lib/", work_dir);
	execute_cmd("cp /usr/lib/libk5crypto* %s/usr/lib/", work_dir);
	execute_cmd("cp /usr/lib/libxml2* %s/usr/lib/", work_dir);
	execute_cmd("cp /usr/bin/php* %s/", work_dir);
	execute_cmd("chmod +rx %s/Main.php", work_dir);

}
Exemplo n.º 8
0
int execute_cmd(char *cmd, int in)
{
    char *p = cmd;
    char *start_cmd = cmd;
    int pipefd[2];
    while (*p) {
        switch (*p) {
            case '|':
                *p++ = 0;
                //创建一个管道
                pipe(pipefd);
                //下面的语句执行后,程序分叉,第一叉在当前捕获的命令,第二
                //叉在后面继续解析命令
                //将写管道传给当前捕获的命令用于重定向其stdout
                if (fork_and_exec(start_cmd, in, pipefd[1]) > 0) {
                    //将读管道传给将要被捕获的命令用于重定向其stdin
                    goto call_forward_pipe_chain;
                }
                break;
            default:
                p++;
        }
    }
    fork_and_exec(start_cmd, in, -1);
    fflush(stdout);
    return 0;
call_forward_pipe_chain:
    execute_cmd(p, pipefd[0]);
    fflush(stdout);
    return 0;
}
Exemplo n.º 9
0
int main(int argc, char * argv[])
{	
	char current_path[] = "0:/";
	
	printf(SHELL_BANNER",%s,v%d。\n", __DATE__, SHELL_VERSION);
	printf("输入help获取帮助.\n");
	
	/* Loop to get char */
	while(1)
	{
		int ch;

		/* 获取当前路径 */

		/* 打印提示符 */
		printf("[%s]#", current_path);
		ch = read_input(line_buffer, MAX_LINE_SIZE);
		printf("\n");
 
		/* 回车键则执行命令 */
		if (ch == SHELL_KEY_ENTER)
		{
			execute_cmd(line_buffer);	
		}		
	}

	return 0;
}
Exemplo n.º 10
0
/*
 * SPI Start Interrupt, this should never get called when chip select is high.
 *
 * NOTE: This is intentionally not done with an overflow interrupt,
 * as the software chip select interrupt will be triggered almost at
 * the same time as an SPI overflow, causing the SPI interrupt to not be
 * handled.
 */
ISR(USI_STR_vect, ISR_BLOCK) {
    // wait for overflow flag to become 1
    while (!(USISR & _BV(USIOIF)))
        ;

    // get data from USIDR
    uint8_t recv_data = USIDR;

    // clear the SPI start flag
    USISR |= _BV(USISIF);
    // clear the overflow flag
    USISR |= _BV(USIOIF);

    // increment our received byte count and take appropiate action
    byte_cnt++;
    if (byte_cnt == 1) {
        // we don't have a command already, set the response
        // buffer to the command we received to let the
        // master confirm the given command if desired, top
        // bit is set if currently charging
        cur_command_ = recv_data;
        USIDR = cur_command_;
    } else if (byte_cnt == 2) {
        // execute the currently set command with
        // the newly given argument, set the response
        // buffer to our return value
        USIDR = execute_cmd(cur_command_, recv_data);
    } else {
        USIDR = 0x11;
    }
}
Exemplo n.º 11
0
uint8 FSDrive::Open(int channel, const uint8 *name, int name_len)
{
	set_error(ERR_OK);

	// Channel 15: Execute file name as command
	if (channel == 15) {
		execute_cmd(name, name_len);
		return ST_OK;
	}

	// Close previous file if still open
	if (file[channel]) {
		fclose(file[channel]);
		file[channel] = NULL;
	}

	if (name[0] == '#') {
		set_error(ERR_NOCHANNEL);
		return ST_OK;
	}

	if (name[0] == '$')
		return open_directory(channel, name + 1, name_len - 1);

	return open_file(channel, name, name_len);
}
Exemplo n.º 12
0
/**
 * Drops the SAs for the given contact.
 * @param c - the contact to drop the SAs for
 * \note Should be called some time after the deregistration, to allow the 200 OK for 
 * De-REGISTER and other messages to still reach the client and responses to be relayed 
 * to the network.
 */
void P_security_drop(r_contact *c,r_security *s)
{
	char drop[256];
	r_ipsec *i;
	if (!s||!c) return;
	switch (s->type){
		case SEC_NONE:
			break;
		case SEC_TLS:
			//TODO!!!
			break;
		case SEC_IPSEC:
			i = s->data.ipsec;
			if (!i) return;
			sprintf(drop,"%s %.*s %d %d %s %d %d %d %d %d %d",
				pcscf_ipsec_P_Drop,
				c->host.len,c->host.s,
				i->port_uc,
				i->port_us,
				pcscf_ipsec_host,
				pcscf_ipsec_port_c,
				pcscf_ipsec_port_s,
				i->spi_uc,
				i->spi_us,
				i->spi_pc,
				i->spi_ps);		
			execute_cmd(drop);
			break;
	}
}
Exemplo n.º 13
0
Arquivo: shell.c Projeto: 7u83/actube
void shell_loop (FILE *file)
{
	struct shelldata sd;
	int c;
	/*	setvbuf(file,NULL,_IONBF,0);
		fflush(file);
	*/
	
	char str[2048];
	sd.update_cfg = cw_ktv_create();
	
	
	
	sd.out = file;
	sprintf(sd.prompt,"%s","*");
	
	do {
		fprintf (file, "actube[%s]:>", sd.prompt);
		fflush (file);
		str[0]=0;
		fgets (str, sizeof (str), file);
		execute_cmd (&sd, str);
		
	} while (c != EOF);
	
}
Exemplo n.º 14
0
int fix_gcc_result(const char *stderr_compiler) {
    if (oj_solution.lang != LANG_C99 &&
        oj_solution.lang != LANG_C11 &&
        oj_solution.lang != LANG_CPP98 &&
        oj_solution.lang != LANG_CPP11 &&
        oj_solution.lang != LANG_CPP14 &&
        oj_solution.lang != LANG_CPP17) {
        return 0;
    }

    int comp_res = execute_cmd("/bin/grep -q 'compiler error' %s", stderr_compiler);
    if (!comp_res) {
        execute_cmd("/bin/sed -n -i '1p' stderr_compiler.txt");
        return 1;
    }

    return 0;
}
Exemplo n.º 15
0
void copy_shell_runtime(char * work_dir) {


	execute_cmd("mkdir %s/lib", work_dir);
	execute_cmd("mkdir %s/lib64", work_dir);
	execute_cmd("mkdir %s/bin", work_dir);
	execute_cmd("cp /lib/* %s/lib/", work_dir);
	execute_cmd("cp /lib64/* %s/lib64/", work_dir);
	execute_cmd("cp -a /lib32 %s/", work_dir);
	execute_cmd("cp /bin/busybox %s/bin/", work_dir);
	execute_cmd("ln -s /bin/busybox %s/bin/sh", work_dir);
	execute_cmd("cp /bin/bash %s/bin/bash", work_dir);


}
Exemplo n.º 16
0
/*
    Get Problem's Input/Output/TimeLimit/MemoryLimit
*/
bool run_judge_client_problem(int solution_id, int problem_id, int &time_limit, int &memory_limit){

    MYSQL_RES* mysql_result = mysql_con.run_sql_world("SELECT * FROM %s WHERE problem_id = %d",
        MYSQL_MESSAGE::problem_name,
        problem_id);

    MYSQL_ROW mysql_row = mysql_fetch_row(mysql_result);

    if(mysql_row != NULL){

/*
        Get I/O File from database.

        //Inpit
        char path[BUFFER_SIZE];

        sprintf(path, "%d", solution_id);

        string file = string(path) + "/" + problem.in_file;

        FILE *fp = fopen(file.c_str(), "w");

        fprintf(fp, "%s", mysql_row[PROBLEM_TABLE::input]);

        fclose(fp);

        //Output
        file = string(path) + "/" + problem.out_file;

        fp = fopen(file.c_str(), "w");

        fprintf(fp, "%s", mysql_row[PROBLEM_TABLE::output]);

        fclose(fp);
*/

        //IO FILE
        char cp_from[BUFFER_SIZE], cp_to[BUFFER_SIZE];

        sprintf(cp_from, "%s/%d", io_file_path.c_str(), problem_id);

        sprintf(cp_to, "%d/%s", solution_id, problem.io_path.c_str());

        execute_cmd("cp -a %s %s", cp_from, cp_to);

        //TimeLimit
        time_limit = atoi(mysql_row[PROBLEM_TABLE::time_limit]);

        //MemoryLimit
        memory_limit = atoi(mysql_row[PROBLEM_TABLE::memory_limit]);
    }
    else
        return false;
}
Exemplo n.º 17
0
int main(void)
{
	int i, background;
	char input[MAX];
	char path[MAX] = ".";
	char entry_dir[MAX] = {0};
	char working_dir[MAX] = {0};
	char *arguments[512] = {0}; /* enter up to 511 arguments, one is reserved for the execution cmd */

	getcwd(entry_dir, sizeof(entry_dir)); /* get the entry directory */

	/* infinite loop until the user enters exit */
	while (1) {
		signal(SIGINT, ctrlc_handler); /* signalhandler to avoid CTRL+C killing the shell */

		prompt(path);
		fgets(input, MAX, stdin); /* read from standardinput */
		i = 0;

		while (input[i] != '\n')
			i++;
		input[i] = '\0'; /* remove newline from read string and replace it with \0 */

		background = parse_input(input, arguments); /* parse string and set background/pipe option */

		if (*arguments != 0){ /* press Enter without SEGfault :P */
			/* all ifs are built-ins for the shell, except for the else */
			if (strcmp(arguments[0], "exit") == 0)
				return 0;
			else if (background == 2) {
				execute_pipe(arguments);
			} else if (strcmp(arguments[0], "cd") == 0) {
				if (arguments[1] == NULL) { /* change to user's HOME if only cd is entered */
					chdir(getenv("HOME"));
					getcwd(working_dir, sizeof(working_dir));
					print_current_dir(entry_dir, working_dir, path);
				} else {
					chdir(arguments[1]);
					getcwd(working_dir, sizeof(working_dir));
					print_current_dir(entry_dir, working_dir, path);
				}
			} else if (strcmp(arguments[0], "wait") == 0) {
				if (arguments[1] == NULL) /* maybe there is no pid given by the user */
					puts("No PID!");
				else {
					keepWaiting = 1;
					waiting(arguments);
				}
			} else {
				execute_cmd(arguments, background);
			}
		}
	}
}
Exemplo n.º 18
0
void execute_shell(SystemMem *SysMem_s)
{
    char inputBuffer[MAX_INPUT_LENGTH]; // Taille max d'une commande saisie par l'utilisateur
    InputCmd InputCmd_s; // Struct de la commande saisie
    fflush(stdin);

    // DEBUG
#ifdef DEBUG
    char count_str[MAX_INPUT_LENGTH];
    char time_str[1000];
    int count = 1;
    time_t starttime;
    starttime = time(NULL);
#endif     

    // Demande une commande à l'utilisateur
    while (fgets(inputBuffer, MAX_INPUT_LENGTH, stdin)) {

        // Récupération de la commande et du path dans la chaîne saisie par l'utilisateur
        if (parse_input_data(inputBuffer, &InputCmd_s) == 0) {
            // Traite la commande de fin
            if (is_exit_cmd(InputCmd_s.cmdStr))
                break; // Quit

            // Traite les commandes    
            if (strcmp(InputCmd_s.cmdStr, "") != 0 && is_valid_cmd(InputCmd_s)) // strcmp permet une saisie vide
                execute_cmd(SysMem_s, &InputCmd_s);
        }

#ifdef DEBUG
        sprintf(count_str, "%d", count);
        sprintf(time_str, "%ld", (time(NULL) - starttime));

        fprintf(stderr, "DEBUG-> (");
        fprintf(stderr, count_str);
        fprintf(stderr, ") CMD: [");
        fprintf(stderr, InputCmd_s.cmdStr);
        fprintf(stderr, "] PATH: [");
        fprintf(stderr, InputCmd_s.pathStr);
        fprintf(stderr, "] WRITESTR: [");
        fprintf(stderr, InputCmd_s.dataStr);
        fprintf(stderr, "] @");
        fprintf(stderr, time_str);
        fprintf(stderr, "secs\n");

        count++;
#endif  

        strcpy(InputCmd_s.cmdStr, ""); // Reset
        strcpy(InputCmd_s.pathStr, ""); // Reset
        strcpy(InputCmd_s.dataStr, ""); // Reset
    }
}
Exemplo n.º 19
0
void prepare_files(char * filename, int namelen, char * infile, int & p_id,
		char * work_dir, char * outfile, char * userfile, int runner_id) {
	//              printf("ACflg=%d %d check a file!\n",ACflg,solution_id);

	char  fname[BUFFER_SIZE];
	strncpy(fname, filename, namelen);
	fname[namelen] = 0;
	sprintf(infile, "%s/data/%d/%s.in", oj_home, p_id, fname);
	execute_cmd("cp %s %sdata.in", infile, work_dir);

	sprintf(outfile, "%s/data/%d/%s.out", oj_home, p_id, fname);
	sprintf(userfile, "%s/run%d/user.out", oj_home, runner_id);
}
Exemplo n.º 20
0
SETUP()
{
	static const cmd_add_t move = {
	  .name = "move",       .abbr = "m",   .id = -1,            .descr = "descr",
	  .flags = HAS_EMARK | HAS_RANGE | HAS_BG_FLAG | HAS_QUOTED_ARGS
	         | HAS_QMARK_NO_ARGS | HAS_SELECTION_SCOPE,
	  .handler = &move_cmd, .min_args = 0, .max_args = NOT_DEF,
	};

	add_builtin_commands(&move, 1);

	assert_success(execute_cmd("command udf a"));
	assert_success(execute_cmd("command mkcd! a"));
	assert_success(execute_cmd("command mkcd? a"));
}

static int
move_cmd(const cmd_info_t *cmd_info)
{
	move_cmd_called = 1;
	return 0;
}
Exemplo n.º 21
0
int handle_cmd() {
	wprintf(L"\n");
	wprintf(L"CMD: ");
	move_begin_list(buffer);
	print_buffer(false);
	wprintf(L"\n");

	free_buffer_content();

	execute_cmd();

	return RET_OK;
}
Exemplo n.º 22
0
Arquivo: sample.c Projeto: hwwr/test
/*实际应用中,处理服务器指令是异步方式,需要厂家处理完毕后主动上报一次设备状态*/
int ICACHE_FLASH_ATTR rawdata_set_callback(char *rawdata, int len)
{
	// TODO: 
	//get cmd from server, do your job here!
	int ret = 0;
	wsf_deb("%s %d \n", __FUNCTION__, __LINE__);
	ret = execute_cmd(rawdata, len);
	//ret=alink_device_post_raw_data();
	// do your job end!
	delta_time = system_get_time();
	device_status_change = 1;
	return ret;
}
Exemplo n.º 23
0
void cmd_thread_func() {
    while(1) {
        svcWaitSynchronization(new_cmd_event, U64_MAX);
        svcClearEvent(new_cmd_event);

        if(thread_exit) svcExitThread();

        last_cmd = cmd.type;
        last_cmd_result = execute_cmd(sock, &cmd);

        svcSignalEvent(cmd_done_event);
    }
}
Exemplo n.º 24
0
/*
 * Function:	create_default_fdisk_partition
 *
 * Parameters:  op - CCIMObjectPath pointer that points to the object path
 *		of the device to fdisk.
 *
 * Returns:	Returns a CCIMProperty pointer.  The CCIMProperty referenced
 *		by the pointer will contain an mValue of cim_true for
 *		success or cim_false on failure.
 *
 * Description:	Executes the fdisk command on the device pointed to my 'op'
 *		with the -B parameter.
 *
 * Notes:	The calling program is responsible for releasing the memory
 *		used by the returned CCIMProperty.
 */
CCIMProperty *
create_default_fdisk_partition(CCIMObjectPath *op)
{
	char		devpath[MAXPATHLEN];
	char		err_file[L_tmpnam];
	char		command_line[CMDLEN];
	int		len;
	int		error;

	/* This function is called from Solaris_DiskDrive, not Solaris_Disk. */
	if (!check_rights("Solaris_DiskDrive") || op == NULL) {
	    return (create_result(PROPFALSE));
	}

	if (get_devpath(op, devpath, sizeof (devpath)) == cim_false) {
	    util_handleError(INVOKE_METHOD, CIM_ERR_INVALID_PARAMETER,
		CIM_ERR_FAILED, NULL, &error);
	    return (create_result(PROPFALSE));
	}
	make_fdisk_path(devpath);

	(void) tmpnam(err_file);

	/*
	 * Build the fdisk command line.  Some combinations of
	 * parameters can cause fdisk to output a message and wait
	 * for a y/n response, echo'ing an 'n' and piping it to
	 * fdisk solves this problem.
	 *
	 * Using the form of fdisk (-F) that takes partition information
	 * from a disk file so that multiple partitions can be created
	 * by one request.
	 */

	len = snprintf(command_line, sizeof (command_line),
	    "echo n | /usr/sbin/fdisk -B %s 2> %s",
	    devpath, err_file);

	if (len < 0 || (len + 1) > sizeof (command_line)) {
	    util_handleError(INVOKE_METHOD, CIM_ERR_FAILED,
		NULL, NULL, &error);
	    return (create_result(PROPFALSE));
	}

	/* Execute the command. */
	if (!execute_cmd(command_line, err_file)) {
	    return (create_result(PROPFALSE));
	}

	return (create_result(PROPTRUE));
}
int	double_close_chevron_operation(t_core *core, t_mod_pack *packet,
				       t_module *mods)
{
  if (packet->rd_write == ERROR && packet->av != NULL)
    {
      core->err_open = open_file(get_fd(packet, TOK_DCCHV),
				 packet->av[0], get_flags(TOK_DCCHV),
				 get_mode(TOK_DCCHV));
    }
  else if (packet->rd_write != ERROR)
    return (execute_cmd(core, packet, mods));
  else
    return (ERROR);
  return (NO_ERR);
}
Exemplo n.º 26
0
/**
 * We have data from the client, we must route it to the backend.
 * This is simply a case of sending it to the connection that was
 * chosen when we started the client session.
 *
 * @param instance		The router instance
 * @param router_session	The router session returned from the newSession call
 * @param queue			The queue of data buffers to route
 * @return The number of bytes sent
 */
static	int	
execute(ROUTER *instance, void *router_session, GWBUF *queue)
{
CLI_SESSION	*session = (CLI_SESSION *)router_session;

	/* Extract the characters */
	while (queue)
	{
		strncat(session->cmdbuf, GWBUF_DATA(queue), MIN(GWBUF_LENGTH(queue),cmdbuflen-1));
		queue = gwbuf_consume(queue, GWBUF_LENGTH(queue));
	}

	execute_cmd(session);
	return 1;
}
int NOOP_test(static_config *jtpz,dynamic_config *dtpz)
{
	char cmd[100] = "/root/njkk/testftp ";
	char result[100] = {0};
	
	execute_cmd(cmd, result,jtpz,dtpz);
	if (strstr(result,"200") != NULL)
	{
		OpenPort_state = 1;		
		return 0;
	}
	else
	{
		return -1;
	}
}
Exemplo n.º 28
0
int			read_loop(int sockfd, struct in_addr *client_addr)
{
	t_serv_fs		serv_fs;
	int				ret;

	serv_fs.client_addr = client_addr;
	if (!(init_serv_fs(&serv_fs)))
		return (0);
	while (1)
	{
		ret = execute_cmd(sockfd, &serv_fs);
		if (ret < 0)
			return (1);
	}
	return (1);
}
Exemplo n.º 29
0
static void
test_delc_completion(void)
{
	char *completion;

	assert_int_equal(0, execute_cmd("command udf a"));

	reset_completion();
	assert_int_equal(5, complete_cmd("delc u"));
	assert_int_equal(2, get_completion_count());
	if(get_completion_count() == 0)
		return;
	completion = next_completion();
	assert_string_equal("udf", completion);
	free(completion);
}
Exemplo n.º 30
0
/*
 * Function:	writeVolumeName
 *
 * Parameters:	params - CCIMPropertyList pointer.  Property list
 *		containing the new disk label name.
 *		op - CCIMObjectPath pointer.  Object path containing
 *		the deviceId of the disk to label.
 *
 * Returns:	Returns a CCIMProperty pointer.  The CCIMProperty referenced
 *		by the pointer will contain an mValue of cim_true for
 *		success or cim_false on failure.
 *
 * Description:	Executes the fmthard -n volume_name command on the device
 *		pointed to by 'op'.
 */
CCIMProperty *
label_disk(CCIMPropertyList *params, CCIMObjectPath *op)
{
	char		devpath[MAXPATHLEN];
	char		command_line[CMDLEN];
	int		len;
	cimchar		*label;
	int		error;

	if (!check_rights("Solaris_Disk") ||
	    op == NULL || params == NULL) {
	    return (create_result(PROPFALSE));
	}

	if (get_devpath(op, devpath, sizeof (devpath)) == cim_false) {
	    util_handleError(INVOKE_METHOD, CIM_ERR_INVALID_PARAMETER,
		NULL, NULL, &error);
	    return (create_result(PROPFALSE));
	}

	/* Extract the label from the input parameters */
	if ((label = get_prop_val(params->mDataObject)) == NULL) {
	    return (create_result(PROPFALSE));
	}
	if (strlen(label) > 8) {
	    util_handleError(INVOKE_METHOD, CIM_ERR_INVALID_PARAMETER,
		NULL, NULL, &error);
	    return (create_result(PROPFALSE));
	}

	/* Build the command line to execute */

	len = snprintf(command_line, sizeof (command_line),
	    "/usr/sbin/fmthard -n '%s' %s 2> /dev/null", label, devpath);

	if (len < 0 || (len + 1) > sizeof (command_line)) {
	    util_handleError(INVOKE_METHOD, CIM_ERR_INVALID_PARAMETER,
		NULL, NULL, &error);
	    return (create_result(PROPFALSE));
	}

	/* Execute the command. */
	if (!execute_cmd(command_line, "/dev/null")) {
	    return (create_result(PROPFALSE));
	}
	return (create_result(PROPTRUE));
}