コード例 #1
0
ファイル: dup.c プロジェクト: Nakrez/zOS
static struct process *get_parent(struct thread *t)
{
    if (t)
        return t->parent;

    return process_get(0);
}
コード例 #2
0
ファイル: peer.c プロジェクト: SunnyQ/cmu
void handle_user_input(char *line, void *cbdata)
{
    char **chunk_list;
    bt_config_t *config;

    bzero(chunkf, sizeof(chunkf));
    bzero(outf, sizeof(outf));

    config = (bt_config_t *) cbdata;
    if (sscanf(line, "GET %120s %120s", chunkf, outf))
    {
        if (strlen(outf) > 0)
        {
            if ((chunk_list = process_get(chunkf, outf)) == NULL )
            {
                perror("I/O error");
                exit(-1);
            }

            // record all hash chunks for the current download
            work_queue = chunk_list;
            broadcast_query(chunk_list, config);
        }
    }
}
コード例 #3
0
ファイル: webproxy.c プロジェクト: joshfermin/networks
void accept_request(int socket)
{
	char buf[MAX_BUFFER];
	int read_size = 0, len = 0;

	while ((read_size = recv(socket, &buf[len], (MAX_BUFFER-len), 0)) > 0)
	{ 
		char line[read_size];
		char method[32];
		char host[512];
		char http_version[64];
		strncpy(line, &buf[len], sizeof(line));
		len += read_size;
		line[read_size] = '\0';

		printf("Found:  %s\n", line);

		sscanf(line, "%s %s %s", method, host, http_version);
		// printf("%s %s %s\n", method, host, http_version);

		
		if(strncmp(method, "GET", 3) == 0)
		{
			printf("Processing GET");
			process_get(host, socket, line);
		} else {
			printf("This is not a supported method\n");
		}
	}
}
コード例 #4
0
ファイル: read.c プロジェクト: Nakrez/zOS
int vfs_read(struct thread *t, int fd, void *buf, size_t count)
{
    int ret;
    struct process *p;
    struct req_rdwr req;
    struct file *file;

    /* Kernel request */
    if (!t)
        p = process_get(0);
    else
        p = t->parent;

    ret = process_file_from_fd(p, fd, &file);
    if (ret < 0)
        return ret;

    if (!file->f_ops->read)
        return -ENOSYS;

    req.inode = 0;
    if (file->inode)
        req.inode = file->inode->inode;

    req.size = count;
    req.off = file->offset;

    ret = file->f_ops->read(file, p, &req, buf);
    if (ret < 0)
        return ret;

    file->offset = req.off;

    return ret;
}
コード例 #5
0
ファイル: syscall_exit.c プロジェクト: UIKit0/flux
struct thread *syscall_exit(struct thread *image) {

	if (image->proc->pid == 1) {
		debug_panic("init died");
	}

	process_switch(process_get(1));
	process_kill(image->proc);

	return thread_switch(image, schedule_next());
}
コード例 #6
0
ファイル: peer.c プロジェクト: lazyplus/641proj3
void handle_user_input(char *line, void *cbdata) {
    char chunkf[128], outf[128];

    bzero(chunkf, sizeof(chunkf));
    bzero(outf, sizeof(outf));

    if (sscanf(line, "GET %120s %120s", chunkf, outf)) {
        if (strlen(outf) > 0) {
            process_get(chunkf, outf);
        }
    }
}
コード例 #7
0
ファイル: process.c プロジェクト: dpalmer93/porcupine-kernel
bool
process_check_destroy(pid_t pid)
{
    struct process *p = process_get(pid);
    // check whether the process has exited
    if (process_checkon(p) == -1)
        return false;
    
    process_destroy(p->ps_pid);
    // returning true removes pid from the pid_set
    // during pid_set_map()
    return true;
}
コード例 #8
0
// Handle input from Erlang VM
static void outputv(ErlDrvData handle, ErlIOVec *ev) {
    bdb_drv_t* pdrv = (bdb_drv_t*) handle;

    ErlDrvBinary* data = ev->binv[1];

    int command = data->orig_bytes[0]; // First byte is the command
  
    switch(command) {
    case 'O':
        process_open(pdrv, ev);
        break;

    case 'S':
        process_set(pdrv, ev);
        break;

    case 'G':
        process_get(pdrv, ev);
        break;

    case 'D':
        process_del(pdrv, ev);
        break;

    case 'C':
        process_count(pdrv, ev);
        break;

    case 'F':
        process_flush(pdrv, ev);
        break;

    case 'B':
        process_bulk_get(pdrv, ev);
        break;

    case 'Z':
        process_compact(pdrv, ev);
        break;

    case 'T':
        process_truncate(pdrv, ev);
        break;

    default:
        process_unkown(pdrv, ev);
    }

}
コード例 #9
0
ファイル: lseek.c プロジェクト: Nakrez/zOS
int vfs_lseek(struct thread *t, int fd, off_t offset, int whence)
{
    struct file *file;
    struct process *process;

    /* Kernel request */
    if (!t)
        process = process_get(0);
    else
        process = t->parent;

    if (!(whence & VFS_SEEK_SET) && !(whence & VFS_SEEK_CUR) &&
        !(whence & VFS_SEEK_END))
        return -EINVAL;

    if (fd < 0 || fd > PROCESS_MAX_OPEN_FD)
        return -EINVAL;

    file = &process->files[fd];

    if (!file->used)
        return -EINVAL;

    if (whence & VFS_SEEK_SET) {
        if (offset < 0)
            return -EINVAL;

        file->offset = offset;
    } else if (whence & VFS_SEEK_CUR) {
        size_t old_off = file->offset;

        file->offset += offset;

        if (offset < 0 && file->offset > old_off) {
            file->offset = old_off;
            return -EINVAL;
        }

        if (offset > 0 && file->offset < old_off) {
            process->files[fd].offset = old_off;
            return -EINVAL;
        }
    } else {
        kernel_panic("VFS_SEEK_END not implemented yet");
    }

    return 0;
}
コード例 #10
0
/* PURPOSE: Creates a data connection whenever a LIST, GET or PUT command
 *		  is entered by client.	
 */
void create_data_connect(char command[], char ip[], char portnum[]){

	int sock_data;
	struct sockaddr_in inf;
	
	//create a tcp socket
	if ((sock_data = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
    
		perror("\nError in socket()");
		exit(1);
     }
     
    //construct the struct
    memset(&inf, 0, sizeof(inf));       		/* Clear struct */
    inf.sin_family = AF_INET;                  	/* Internet/IP */
    inf.sin_addr.s_addr = inet_addr(ip);  		/* IP address */
    //here we use the port number from the control connection + 1
    inf.sin_port = htons(atoi(portnum) + 1);      /* server port */

    //connect to the server
    if (connect(sock_data, (struct sockaddr *) &inf, sizeof(inf)) < 0) {
		perror("\nError in connect()");
		exit(1);
    }
    
    //if we issued a PUT command
    if(strncmp("PUT", command, 3) == 0){

		process_put(command, sock_data);

    }

    else if(strncmp("GET", command, 3) == 0){

    		process_get(command, sock_data);
    }

    //we issued a LIST command
    else if(strncmp("LIST", command, 4) == 0){
		process_list(sock_data);    

    }
	
    else{
		fprintf(stderr, "\nNot a valid command.\n\n");
    }

}
コード例 #11
0
ファイル: core.c プロジェクト: jonathanmarvens/unbuckle
int process_request(struct request_state* req)
{
	switch (req->cmd)
	{
	case cmd_get:
		if (process_get(req))
			return -1;
		break;
	case cmd_set:
		if (process_set(req))
			return -1;
		break;
	}

	req->state = conn_send;

	return 0;
}
コード例 #12
0
ファイル: tsrm_win32.c プロジェクト: Distrotech/php-src
TSRM_API int pclose(FILE *stream)
{
	DWORD termstat = 0;
	process_pair *process;

	if ((process = process_get(stream)) == NULL) {
		return 0;
	}

	fflush(process->stream);
	fclose(process->stream);

	WaitForSingleObject(process->prochnd, INFINITE);
	GetExitCodeProcess(process->prochnd, &termstat);
	process->stream = NULL;
	CloseHandle(process->prochnd);

	return termstat;
}
コード例 #13
0
ファイル: protocol.c プロジェクト: djjsindy/dawn
intptr_t process_command(connection_t *conn){
  intptr_t result=OK;
  char *data=conn->rc->command->data;
  if(strcmp(data,"get")==0){
    result=process_get(conn);
  }else if(strcmp(data,"set")==0){
    result=process_set(conn);
  }else if(strcmp(data,"version")==0){
    process_version(conn);
  }else if(strcmp(data,"delete")==0){
    result=process_delete(conn);
  }else if(strcmp(data,"quit")==0){
    close_connection(conn);
  }else if(strcmp(data,"stats")==0){
    process_stats(conn);
  }else{
   process_client_error(conn,unsupport_command);
 }
 return result;
}
コード例 #14
0
ファイル: thread.c プロジェクト: jrepan/rhombus
struct thread *thread_send(struct thread *image, pid_t target, portid_t port, struct msg *msg) {
	struct process *p_targ;
	struct thread *new_image;

	/* find target process */
	p_targ = process_get(target);

	/* check process */
	if (!p_targ || !p_targ->entry) {
		return image;
	}

	/* create new thread */
	new_image = thread_alloc();
	thread_bind(new_image, p_targ);

	new_image->ds      = 0x23;
	new_image->cs      = 0x1B;
	new_image->ss      = 0x23;
	new_image->eflags  = 0;
	new_image->useresp = new_image->stack + SEGSZ;
	new_image->proc    = p_targ;
	new_image->eip     = p_targ->entry;

	/* set up registers in new thread */
	new_image->ebx     = 0;
	new_image->ecx     = (msg) ? msg->count : 0;
	new_image->edx     = port;
	new_image->esi     = (image) ? image->proc->pid : 0;
	new_image->edi     = 0;
	new_image->msg     = msg;

	/* set new thread's user id */
	new_image->user = (!image || p_targ->user) ? p_targ->user : image->user;

	/* insert new thread into scheduler */
	schedule_insert(new_image);

	/* return new thread */
	return new_image;
}
コード例 #15
0
ファイル: syscall_exit.c プロジェクト: asegid/rhombus
struct thread *syscall_exit(struct thread *image) {
	struct thread *new_image;
	uint16_t pid;
	uint32_t parent;

	pid = image->proc->pid;

	if (pid == 1) {
		debug_panic("init died");
	}

	parent = image->proc->parent->pid;

	process_switch(process_get(1));

	new_image = thread_send(image, parent, PORT_CHILD, NULL);

	image->proc->status = image->eax;
	process_kill(image->proc);

	return new_image;
}
コード例 #16
0
ファイル: event.c プロジェクト: AndreasFMueller/Focuser
/**
 * \brief Control request event handler
 *
 * This implementation handles the control requests for the GuiderPort device
 */
void	EVENT_USB_Device_ControlRequest() {
	if (is_control()) {
		if (is_incoming()) {
			switch (USB_ControlRequest.bRequest) {
			case FOCUSER_RESET:
				process_reset();
				break;
			case FOCUSER_SET:
				process_set();
				break;
			case FOCUSER_LOCK:
				process_lock();
				break;
			case FOCUSER_STOP:
				process_stop();
				break;
			case FOCUSER_SERIAL:
				process_serial();
				break;
			}
		}
		if (is_outgoing()) {
			switch (USB_ControlRequest.bRequest) {
			case FOCUSER_GET:
				process_get();
				break;
			case FOCUSER_RCVR:
				process_rcvr();
				break;
			case FOCUSER_SAVED:
				process_saved();
				break;
			}
		}
	}
}
コード例 #17
0
void process_requests(void)
{
	int retval = 0;
	request *current, *trailer;

	current = request_ready;

	while (current) {
#ifdef CRASHDEBUG
		crashdebug_current = current;
#endif		
		if (current->buffer_end) {
			req_flush(current);
			if (current->status == CLOSE)
				retval = 0;
			else
				retval = 1;
		} else {
			switch (current->status) {
			case READ_HEADER:
			case ONE_CR:
			case ONE_LF:
			case TWO_CR:
				retval = read_header(current);
				break;
			case BODY_READ:
				retval = read_body(current);
				break;
			case BODY_WRITE:
				retval = write_body(current);
				break;
			case WRITE:
				retval = process_get(current);
				break;
			case PIPE_READ:
				retval = read_from_pipe(current);
				break;
			case PIPE_WRITE:
				retval = write_from_pipe(current);
				break;
			default:
				retval = 0;
#if 0
				fprintf(stderr, "Unknown status (%d), closing!\n",
						current->status);
#endif
				break;
			}
		}
		
		if (lame_duck_mode)
			SQUASH_KA(current);

		switch (retval) {
		case -1:				/* request blocked */
			trailer = current;
			current = current->next;
			block_request(trailer);
			break;
		default:			/* everything else means an error, jump ship */
			send_r_error(current);
			/* fall-through */
		case 0:				/* request complete */
			trailer = current;
			current = current->next;
			free_request(&request_ready, trailer);
			break;
		case 1:				/* more to do */
			current->time_last = time_counter;
			current = current->next;
			break;
		}
	}
#ifdef CRASHDEBUG
		crashdebug_current = current;
#endif
}
コード例 #18
0
ファイル: sftp.c プロジェクト: Hacker-One/backdoor_rootkit
static int
parse_dispatch_command(struct sftp_conn *conn, const char *cmd, char **pwd,
    int err_abort)
{
	char *path1, *path2, *tmp;
	int pflag, lflag, iflag, cmdnum, i;
	unsigned long n_arg;
	Attrib a, *aa;
	char path_buf[MAXPATHLEN];
	int err = 0;
	glob_t g;

	path1 = path2 = NULL;
	cmdnum = parse_args(&cmd, &pflag, &lflag, &iflag, &n_arg,
	    &path1, &path2);

	if (iflag != 0)
		err_abort = 0;

	memset(&g, 0, sizeof(g));

	/* Perform command */
	switch (cmdnum) {
	case 0:
		/* Blank line */
		break;
	case -1:
		/* Unrecognized command */
		err = -1;
		break;
	case I_GET:
		err = process_get(conn, path1, path2, *pwd, pflag);
		break;
	case I_PUT:
		err = process_put(conn, path1, path2, *pwd, pflag);
		break;
	case I_RENAME:
		path1 = make_absolute(path1, *pwd);
		path2 = make_absolute(path2, *pwd);
		err = do_rename(conn, path1, path2);
		break;
	case I_SYMLINK:
		path2 = make_absolute(path2, *pwd);
		err = do_symlink(conn, path1, path2);
		break;
	case I_RM:
		path1 = make_absolute(path1, *pwd);
		remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
			printf("Removing %s\n", g.gl_pathv[i]);
			err = do_rm(conn, g.gl_pathv[i]);
			if (err != 0 && err_abort)
				break;
		}
		break;
	case I_MKDIR:
		path1 = make_absolute(path1, *pwd);
		attrib_clear(&a);
		a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
		a.perm = 0777;
		err = do_mkdir(conn, path1, &a);
		break;
	case I_RMDIR:
		path1 = make_absolute(path1, *pwd);
		err = do_rmdir(conn, path1);
		break;
	case I_CHDIR:
		path1 = make_absolute(path1, *pwd);
		if ((tmp = do_realpath(conn, path1)) == NULL) {
			err = 1;
			break;
		}
		if ((aa = do_stat(conn, tmp, 0)) == NULL) {
			xfree(tmp);
			err = 1;
			break;
		}
		if (!(aa->flags & SSH2_FILEXFER_ATTR_PERMISSIONS)) {
			error("Can't change directory: Can't check target");
			xfree(tmp);
			err = 1;
			break;
		}
		if (!S_ISDIR(aa->perm)) {
			error("Can't change directory: \"%s\" is not "
			    "a directory", tmp);
			xfree(tmp);
			err = 1;
			break;
		}
		xfree(*pwd);
		*pwd = tmp;
		break;
	case I_LS:
		if (!path1) {
			do_globbed_ls(conn, *pwd, *pwd, lflag);
			break;
		}

		/* Strip pwd off beginning of non-absolute paths */
		tmp = NULL;
		if (*path1 != '/')
			tmp = *pwd;

		path1 = make_absolute(path1, *pwd);
		err = do_globbed_ls(conn, path1, tmp, lflag);
		break;
	case I_LCHDIR:
		if (chdir(path1) == -1) {
			error("Couldn't change local directory to "
			    "\"%s\": %s", path1, strerror(errno));
			err = 1;
		}
		break;
	case I_LMKDIR:
		if (mkdir(path1, 0777) == -1) {
			error("Couldn't create local directory "
			    "\"%s\": %s", path1, strerror(errno));
			err = 1;
		}
		break;
	case I_LLS:
		local_do_ls(cmd);
		break;
	case I_SHELL:
		local_do_shell(cmd);
		break;
	case I_LUMASK:
		umask(n_arg);
		printf("Local umask: %03lo\n", n_arg);
		break;
	case I_CHMOD:
		path1 = make_absolute(path1, *pwd);
		attrib_clear(&a);
		a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
		a.perm = n_arg;
		remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
			printf("Changing mode on %s\n", g.gl_pathv[i]);
			err = do_setstat(conn, g.gl_pathv[i], &a);
			if (err != 0 && err_abort)
				break;
		}
		break;
	case I_CHOWN:
	case I_CHGRP:
		path1 = make_absolute(path1, *pwd);
		remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
			if (!(aa = do_stat(conn, g.gl_pathv[i], 0))) {
				if (err != 0 && err_abort)
					break;
				else
					continue;
			}
			if (!(aa->flags & SSH2_FILEXFER_ATTR_UIDGID)) {
				error("Can't get current ownership of "
				    "remote file \"%s\"", g.gl_pathv[i]);
				if (err != 0 && err_abort)
					break;
				else
					continue;
			}
			aa->flags &= SSH2_FILEXFER_ATTR_UIDGID;
			if (cmdnum == I_CHOWN) {
				printf("Changing owner on %s\n", g.gl_pathv[i]);
				aa->uid = n_arg;
			} else {
				printf("Changing group on %s\n", g.gl_pathv[i]);
				aa->gid = n_arg;
			}
			err = do_setstat(conn, g.gl_pathv[i], aa);
			if (err != 0 && err_abort)
				break;
		}
		break;
	case I_PWD:
		printf("Remote working directory: %s\n", *pwd);
		break;
	case I_LPWD:
		if (!getcwd(path_buf, sizeof(path_buf))) {
			error("Couldn't get local cwd: %s", strerror(errno));
			err = -1;
			break;
		}
		printf("Local working directory: %s\n", path_buf);
		break;
	case I_QUIT:
		/* Processed below */
		break;
	case I_HELP:
		help();
		break;
	case I_VERSION:
		printf("SFTP protocol version %u\n", sftp_proto_version(conn));
		break;
	case I_PROGRESS:
		showprogress = !showprogress;
		if (showprogress)
			printf("Progress meter enabled\n");
		else
			printf("Progress meter disabled\n");
		break;
	default:
		fatal("%d is not implemented", cmdnum);
	}

	if (g.gl_pathc)
		globfree(&g);
	if (path1)
		xfree(path1);
	if (path2)
		xfree(path2);

	/* If an unignored error occurs in batch mode we should abort. */
	if (err_abort && err != 0)
		return (-1);
	else if (cmdnum == I_QUIT)
		return (1);

	return (0);
}
コード例 #19
0
ファイル: peer.c プロジェクト: SunnyQ/cmu
void peer_run(bt_config_t *config)
{
    struct sockaddr_in myaddr;
    fd_set readfds;
    struct user_iobuf *userbuf;
    struct timeval timeout;
    int i, j;

    if ((userbuf = create_userbuf()) == NULL )
    {
        perror("peer_run could not allocate userbuf");
        exit(-1);
    }

    if ((config->sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) == -1)
    {
        perror("peer_run could not create socket");
        exit(-1);
    }

    bzero(&myaddr, sizeof(myaddr));
    myaddr.sin_family = AF_INET;
    myaddr.sin_addr.s_addr = htonl(INADDR_ANY );
    myaddr.sin_port = htons(config->myport);

    if (bind(config->sock, (struct sockaddr *) &myaddr, sizeof(myaddr)) == -1)
    {
        perror("peer_run could not bind socket");
        exit(-1);
    }

    spiffy_init(config->identity, (struct sockaddr *) &myaddr, sizeof(myaddr));

    timeout.tv_sec = 1;
    while (1)
    {
        int nfds;
        FD_SET(STDIN_FILENO, &readfds);
        FD_SET(config->sock, &readfds);

        nfds = select(config->sock + 1, &readfds, NULL, NULL, &timeout);

        if (nfds > 0)
        {
            if (FD_ISSET(config->sock, &readfds))
                process_inbound_udp(config->sock, config);

            if (FD_ISSET(STDIN_FILENO, &readfds))
                process_user_input(STDIN_FILENO, userbuf, handle_user_input,
                        config);
        }
        // check timeout
        if (timeout.tv_sec == 0)
        {
            for (i = 0; i < BT_MAX_PEERS; i++)
            {
                for (j = 0; j < BT_CHUNK_SIZE; j++)
                {
                    if (TTL[i][j] != -1)
                        TTL[i][j]++;

                    // set the DATA timeout to 2
                    if (TTL[i][j] == 2)
                    {
                        dprintf(STDOUT_FILENO, "retransmitting on timeout %d\n",
                                j + 1);
                        lastSent[i] = j; // lastACKed should be the same as j
                        sendData(*getAddr(config, i), config);
                        dup_ack[i] = 0;
                        break;
                    }
                }
                if (GETTTL[i] != -1)
                    GETTTL[i]++;

                // set the GET timeout to 5
                if (GETTTL[i] == 5)
                {
                    if (++numGetMisses[i] > 3)
                    {
                        numGetMisses[i] = 0;
                        numDataMisses[i] = -1;
                        jobs[i] = -1;
                        dup_ack[i] = 0;
                        GETTTL[i] = -1;
                        windowSize[i] = 0;
                        congestionState[i] = -1;
                        if ((work_queue = process_get(chunkf, outf)) == NULL )
                        {
                            perror("I/O error");
                            exit(-1);
                        }
                        GETTTL[i] = -1;
                        broadcast_query(work_queue, config);
                    }
                    else
                    {
                        dprintf(STDOUT_FILENO, "resending GET\n");
                        if ((work_queue = process_get(chunkf, outf)) == NULL )
                        {
                            perror("I/O error");
                            exit(-1);
                        }
                        sendGetSW(config->sock, *getAddr(config, i));
                    }
                }

                if (numDataMisses[i] != -1)
                    numDataMisses[i]++;

                if (numDataMisses[i] > 15)
                {
                    numDataMisses[i] = -1;
                    jobs[i] = -1;
                    dup_ack[i] = 0;
                    GETTTL[i] = -1;
                    windowSize[i] = 0;
                    congestionState[i] = -1;
                    numGetMisses[i] = 0;
                    resetCCRTT();
                    if ((work_queue = process_get(chunkf, outf)) == NULL )
                    {
                        perror("I/O error");
                        exit(-1);
                    }
                    broadcast_query(work_queue, config);
                }
            }
            timeout.tv_sec = 1;
        }
    }
}
コード例 #20
0
ファイル: ipc.c プロジェクト: zrho/Carbon
void syscall_ipc_send(cpu_int_state_t *state) {
	// Extract arguments
	uint32_t pid = (uint32_t) state->state.rdi;
	uint16_t flags = (uint32_t) state->state.rbx;
	uint32_t length = (uint32_t) state->state.rcx;

	// Check if process exists
	process_t *process_target = (pid == process_current->pid)
			? process_current
			: process_get(pid);

	if (0 == process_target)
		SYSCALL_RETURN_ERROR(1);

	// Check handler
	if (0 == process_target->message_handler)
		SYSCALL_RETURN_ERROR(2);

	// Check buffer size
	if (length > thread_current->ipc_buffer_sz[IPC_BUFFER_SEND])
		SYSCALL_RETURN_ERROR(3);

	// Spawn handler thread
	thread_t *handler = thread_spawn(
			process_target,
			process_target->message_handler);

	// Set thread role
	ipc_role_ctx_t *role_ctx =
			(ipc_role_ctx_t *) heap_alloc(sizeof(ipc_role_ctx_t));

	role_ctx->flags = flags;
	role_ctx->sender_process = process_current->pid;
	role_ctx->sender_thread = thread_current->tid;

	handler->role = THREAD_ROLE_IPC_RECEIVER;
	handler->role_ctx = role_ctx;

	// Move buffer to handler thread
	if (length > 0)
		ipc_buffer_move(
				thread_current,
				IPC_BUFFER_SEND,
				handler,
				IPC_BUFFER_RECV,
				process_target);

	// Write header to registers
	ipc_message_header(
			IPC_BUFFER_RECV,
			length,
			flags,
			process_current->pid,
			handler->tid,
			&handler->state);

	// Freeze the invoking thread, if a response is expected
	if (0 == (flags & IPC_FLAG_IGNORE_RESPONSE))
		thread_freeze(thread_current);

	// Switch to handler thread
	thread_switch(handler, state);
}
コード例 #21
0
ファイル: ipc.c プロジェクト: zrho/Carbon
void syscall_ipc_respond(cpu_int_state_t *state) {
	// Check thread role
	if (THREAD_ROLE_IPC_RECEIVER != thread_current->role)
		SYSCALL_RETURN_ERROR(1);

	// Extract arguments
	uint16_t flags = (uint16_t) state->state.rbx;
	uint32_t length = (uint32_t) state->state.rcx;

	// Check length
	if (length > thread_current->ipc_buffer_sz[IPC_BUFFER_SEND])
		SYSCALL_RETURN_ERROR(2);

	// Extract info from role ctx
	ipc_role_ctx_t *role_ctx = (ipc_role_ctx_t *) thread_current->role_ctx;
	uint32_t sender_pid = role_ctx->sender_process;
	uint32_t sender_tid = role_ctx->sender_thread;

	// Sender process still exists?
	process_t *sender_process = process_get(sender_pid);

	if (0 == sender_process) {
		thread_stop(process_current, thread_current);
		thread_switch(scheduler_next(), state);
		return;
	}

	// Sender thread still exists?
	thread_t *sender_thread = thread_get(sender_process, sender_tid);

	if (0 == sender_thread) {
		thread_stop(process_current, thread_current);
		thread_switch(scheduler_next(), state);
		return;
	}

	// Response ignored?
	if (0 != (role_ctx->flags & IPC_FLAG_IGNORE_RESPONSE)) {
		thread_stop(process_current, thread_current);
		thread_switch(sender_thread, state);
		return;
	}

	// Move buffer to sender thread (if length > 0)
	if (length > 0)
		ipc_buffer_move(
				thread_current,
				IPC_BUFFER_SEND,
				sender_thread,
				IPC_BUFFER_RECV,
				sender_process);

	// Write header to registers
	ipc_message_header(
			IPC_BUFFER_RECV,
			length,
			flags,
			process_current->pid,
			sender_thread->tid,
			&sender_thread->state);

	// Thaw thread
	thread_thaw(sender_thread, 0);

	// Stop current thread and switch to sender
	thread_stop(process_current, thread_current);
	thread_switch(sender_thread, state);
}
コード例 #22
0
ファイル: tsrm_win32.c プロジェクト: Distrotech/php-src
TSRM_API FILE *popen_ex(const char *command, const char *type, const char *cwd, char *env)
{
	FILE *stream = NULL;
	int fno, type_len, read, mode;
	STARTUPINFO startup;
	PROCESS_INFORMATION process;
	SECURITY_ATTRIBUTES security;
	HANDLE in, out;
	DWORD dwCreateFlags = 0;
	BOOL res;
	process_pair *proc;
	char *cmd;
	int i;
	char *ptype = (char *)type;
	HANDLE thread_token = NULL;
	HANDLE token_user = NULL;
	BOOL asuser = TRUE;

	if (!type) {
		return NULL;
	}

	/*The following two checks can be removed once we drop XP support */
	type_len = (int)strlen(type);
	if (type_len <1 || type_len > 2) {
		return NULL;
	}

	for (i=0; i < type_len; i++) {
		if (!(*ptype == 'r' || *ptype == 'w' || *ptype == 'b' || *ptype == 't')) {
			return NULL;
		}
		ptype++;
	}

	security.nLength				= sizeof(SECURITY_ATTRIBUTES);
	security.bInheritHandle			= TRUE;
	security.lpSecurityDescriptor	= NULL;

	if (!type_len || !CreatePipe(&in, &out, &security, 2048L)) {
		return NULL;
	}

	memset(&startup, 0, sizeof(STARTUPINFO));
	memset(&process, 0, sizeof(PROCESS_INFORMATION));

	startup.cb			= sizeof(STARTUPINFO);
	startup.dwFlags		= STARTF_USESTDHANDLES;
	startup.hStdError	= GetStdHandle(STD_ERROR_HANDLE);

	read = (type[0] == 'r') ? TRUE : FALSE;
	mode = ((type_len == 2) && (type[1] == 'b')) ? O_BINARY : O_TEXT;

	if (read) {
		in = dupHandle(in, FALSE);
		startup.hStdInput  = GetStdHandle(STD_INPUT_HANDLE);
		startup.hStdOutput = out;
	} else {
		out = dupHandle(out, FALSE);
		startup.hStdInput  = in;
		startup.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
	}

	dwCreateFlags = NORMAL_PRIORITY_CLASS;
	if (strcmp(sapi_module.name, "cli") != 0) {
		dwCreateFlags |= CREATE_NO_WINDOW;
	}

	/* Get a token with the impersonated user. */
	if(OpenThreadToken(GetCurrentThread(), TOKEN_ALL_ACCESS, TRUE, &thread_token)) {
		DuplicateTokenEx(thread_token, MAXIMUM_ALLOWED, &security, SecurityImpersonation, TokenPrimary, &token_user);
	} else {
		DWORD err = GetLastError();
		if (err == ERROR_NO_TOKEN) {
			asuser = FALSE;
		}
	}

	cmd = (char*)malloc(strlen(command)+strlen(TWG(comspec))+sizeof(" /c ")+2);
	if (!cmd) {
		return NULL;
	}

	sprintf(cmd, "%s /c \"%s\"", TWG(comspec), command);
	if (asuser) {
		res = CreateProcessAsUser(token_user, NULL, cmd, &security, &security, security.bInheritHandle, dwCreateFlags, env, cwd, &startup, &process);
		CloseHandle(token_user);
	} else {
		res = CreateProcess(NULL, cmd, &security, &security, security.bInheritHandle, dwCreateFlags, env, cwd, &startup, &process);
	}
	free(cmd);

	if (!res) {
		return NULL;
	}

	CloseHandle(process.hThread);
	proc = process_get(NULL);

	if (read) {
		fno = _open_osfhandle((tsrm_intptr_t)in, _O_RDONLY | mode);
		CloseHandle(out);
	} else {
		fno = _open_osfhandle((tsrm_intptr_t)out, _O_WRONLY | mode);
		CloseHandle(in);
	}

	stream = _fdopen(fno, type);
	proc->prochnd = process.hProcess;
	proc->stream = stream;
	return stream;
}
コード例 #23
0
ファイル: request.c プロジェクト: pretendchang/IoTGateway
void process_requests(int server_sock)
{
    int retval = 0;
    request *current, *trailer;

    if (pending_requests) {
        get_request(server_sock);
#ifdef ORIGINAL_BEHAVIOR
        pending_requests = 0;
#endif
    }

    current = request_ready;

    while (current) {
        time(&current_time);
        retval = 1;             /* emulate "success" in case we don't have to flush */

        if (current->buffer_end && /* there is data in the buffer */
            current->status < TIMED_OUT) {
            retval = req_flush(current);
            /*
             * retval can be -2=error, -1=blocked, or bytes left
             */
            if (retval == -2) { /* error */
                current->status = DEAD;
                retval = 0;
            } else if (retval >= 0) {
                /* notice the >= which is different from below?
                   Here, we may just be flushing headers.
                   We don't want to return 0 because we are not DONE
                   or DEAD */
                retval = 1;
            }
        }

        if (retval == 1) {
            switch (current->status) {
            case READ_HEADER:
            case ONE_CR:
            case ONE_LF:
            case TWO_CR:
                retval = read_header(current);
                break;
            case BODY_READ:
                retval = read_body(current);
                break;
            case BODY_WRITE:
                retval = write_body(current);
                break;
            case WRITE:
                retval = process_get(current);
                break;
            case PIPE_READ:
                retval = read_from_pipe(current);
                break;
            case PIPE_WRITE:
                retval = write_from_pipe(current);
                break;
            case IOSHUFFLE:
#ifdef HAVE_SENDFILE
                retval = io_shuffle_sendfile(current);
#else
                retval = io_shuffle(current);
#endif
                break;
            case DONE:
                /* a non-status that will terminate the request */
                retval = req_flush(current);
                /*
                 * retval can be -2=error, -1=blocked, or bytes left
                 */
                if (retval == -2) { /* error */
                    current->status = DEAD;
                    retval = 0;
                } else if (retval > 0) {
                    retval = 1;
                }
                break;
            case TIMED_OUT:
            case DEAD:
                retval = 0;
                current->buffer_end = 0;
                SQUASH_KA(current);
                break;
            default:
                retval = 0;
                fprintf(stderr, "Unknown status (%d), "
                        "closing!\n", current->status);
                current->status = DEAD;
                break;
            }

        }

        if (sigterm_flag)
        {
          SQUASH_KA(current);
        }

        /* we put this here instead of after the switch so that
         * if we are on the last request, and get_request is successful,
         * current->next is valid!
         */
        if (pending_requests)
            get_request(server_sock);

        switch (retval) {
        case -1:               /* request blocked */
            trailer = current;
            current = current->next;
            block_request(trailer);
            break;
        case 0:                /* request complete */
            current->time_last = current_time;
            trailer = current;
            current = current->next;
            free_request(trailer);
            break;
        case 1:                /* more to do */
            current->time_last = current_time;
            current = current->next;
            break;
        default:
            log_error_doc(current);
            fprintf(stderr, "Unknown retval in process.c - "
                    "Status: %d, retval: %d\n", current->status, retval);
            current->status = DEAD;
            current = current->next;
            break;
        }
    }
}
コード例 #24
0
ファイル: request.c プロジェクト: dulton/boa_onvif
void process_requests(int server_s, struct soap *soap)/*by SeanHou*/
{
    /* :TODO:Monday, December 01, 2014 11:17:36 HKT:SeanHou:  */
    int OnvifEN = 0;
    int lookupindex = 0;
    char service_uri[100] = "";

    memset((void*)&soap->peer, 0, sizeof(soap->peer));
    soap->socket = SOAP_INVALID_SOCKET;
    soap->error  = SOAP_OK;
    soap->errmode = 0;
    soap->keep_alive = 0;

    fprintf(stderr, "Warning:" \
            "(==>%s).\n", __func__);

    /* :TODO:End---  */
    int retval = 0;
    request *current, *trailer;

    if (pending_requests) {
        get_request(server_s);
#ifdef ORIGINAL_BEHAVIOR
        pending_requests = 0;
#endif
    }

    current = request_ready;

    while (current) {
        /* :TODO:Monday, December 01, 2014 11:18:42 HKT:SeanHou: juge is onvif */
        OnvifEN = isonvif(current->client_stream, service_uri, &lookupindex);
        if(OnvifEN == 1)
        {
            fprintf(stderr, "[boa:onvif] Warning: is onvif line[%d]remote port[%d]h2ns[%d]remote ip[%s]\n", __LINE__, current->remote_port, htons(current->remote_port), current->remote_ip_addr);
            struct sockaddr_in onvif_client_addr;
            memset(&onvif_client_addr, 0, sizeof(onvif_client_addr));
            onvif_client_addr.sin_family = AF_INET;
            onvif_client_addr.sin_port = htons(current->remote_port);//随机端口
            onvif_client_addr.sin_addr.s_addr = inet_addr(current->remote_ip_addr);//

            soap->socket = current->fd;
            soap->peer = onvif_client_addr;
            if (soap_valid_socket(soap->socket))
            {
                soap->ip = ntohl(soap->peer.sin_addr.s_addr);
                soap->port = (int)ntohs(soap->peer.sin_port);
                soap->keep_alive = (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) != 0);
            }


            g_onvif_buffer = (char *)soap_malloc(soap, sizeof(current->client_stream));
            strcpy(g_onvif_buffer, current->client_stream);//mark

            soap_begin_recv(soap);
            if (soap_envelope_begin_in(soap))
            {
                soap_send_fault(soap);
            }
            if (soap_recv_header(soap))
            {
                soap_send_fault(soap);
            }
            if (soap_body_begin_in(soap))
            {
                soap_send_fault(soap);
            }

            int errorCode = 0;
            if (errorCode = soap_serve_request(soap))
            {
                fprintf(stderr, "[boa:onvif]soap_serve_request fail, errorCode %d \n", errorCode);
                soap_send_fault(soap);
            }

            memset(current->client_stream, 0, CLIENT_STREAM_SIZE );

            soap_dealloc(soap, NULL);
            soap_destroy(soap);      
            soap_end(soap);
            current->status = DONE;
            close(soap->socket);
            continue;
        }
        /* :TODO:End---  */
        time(&current_time);
        if (current->buffer_end && /* there is data in the buffer */
                current->status != DEAD && current->status != DONE) {
            retval = req_flush(current);
            /*
             * retval can be -2=error, -1=blocked, or bytes left
             */
            if (retval == -2) { /* error */
                current->status = DEAD;
                retval = 0;
            } else if (retval >= 0) {
                /* notice the >= which is different from below?
                   Here, we may just be flushing headers.
                   We don't want to return 0 because we are not DONE
                   or DEAD */

                retval = 1;
            }
        } else {
            switch (current->status) {
                case READ_HEADER:
                case ONE_CR:
                case ONE_LF:
                case TWO_CR:
                    retval = read_header(current);
                    break;
                case BODY_READ:
                    retval = read_body(current);
                    break;
                case BODY_WRITE:
                    retval = write_body(current);
                    break;
                case WRITE:
                    retval = process_get(current);
                    break;
                case PIPE_READ:
                    retval = read_from_pipe(current);
                    break;
                case PIPE_WRITE:
                    retval = write_from_pipe(current);
                    break;
                case DONE:
                    /* a non-status that will terminate the request */
                    retval = req_flush(current);
                    /*
                     * retval can be -2=error, -1=blocked, or bytes left
                     */
                    if (retval == -2) { /* error */
                        current->status = DEAD;
                        retval = 0;
                    } else if (retval > 0) {
                        retval = 1;
                    }
                    break;
                case DEAD:
                    retval = 0;
                    current->buffer_end = 0;
                    SQUASH_KA(current);
                    break;
                default:
                    retval = 0;
                    fprintf(stderr, "Unknown status (%d), "
                            "closing!\n", current->status);
                    current->status = DEAD;
                    break;
            }

        }

        if (sigterm_flag)
            SQUASH_KA(current);

        /* we put this here instead of after the switch so that
         * if we are on the last request, and get_request is successful,
         * current->next is valid!
         */
        if (pending_requests)
            get_request(server_s);

        switch (retval) {
            case -1:               /* request blocked */
                trailer = current;
                current = current->next;
                block_request(trailer);
                break;
            case 0:                /* request complete */
                current->time_last = current_time;
                trailer = current;
                current = current->next;
                free_request(&request_ready, trailer);
                break;
            case 1:                /* more to do */
                current->time_last = current_time;
                current = current->next;
                break;
            default:
                log_error_time();
                fprintf(stderr, "Unknown retval in process.c - "
                        "Status: %d, retval: %d\n", current->status, retval);
                current = current->next;
                break;
        }
    }
}