示例#1
0
int on_data_reception (void * /*cls*/, 
					  struct MHD_Connection* connection,
                      const char* url, 
                      const char* method,
                      const char* /*version*/, 
                      const char* upload_data,
                      size_t* upload_data_size, 
                      void** ioConCtx)
{
    MDW_LOG_DEBUG ("on_data_reception");
		
	// No context: New incoming cnx		
	if (NULL == *ioConCtx)
    {
		return accept_connection(connection, url, method, ioConCtx);
    }

	HttpConnection *con_info = (HttpConnection*) *ioConCtx;
	if (nullptr == con_info)
		return send_reponse (connection, StaticPages::ClientError, MHD_HTTP_BAD_REQUEST);
	
	return con_info->onDataReceived(upload_data, upload_data_size);
}
示例#2
0
int handle_connection(int sock, struct sockaddr_in *addr)
{
    int8_t cmd_type;
    struct fs_open_command cmd_open;
    struct fs_command cmd;
    int read_bytes, ret, file;
    while (1 == recv(sock, &cmd_type, sizeof(cmd_type), MSG_PEEK)) {
        switch (cmd_type) {
        case FSMSG_OPEN:
            recv(sock, &cmd_open, sizeof(cmd_open), MSG_WAITALL);
            cmd_open.filename[255] = 0;
            printf("received FSMSG_OPEN, filename = %s\n", cmd_open.filename);

            file = open(cmd_open.filename, cmd_open.base_command.arg1);
            send_reponse(sock, 0, file);
        
            break;
        case FSMSG_WRITE:
        {
            recv(sock, &cmd, sizeof(cmd), MSG_WAITALL);
            printf("received FSMSG_WRITE, fd = %i\n", cmd.fd);
            
            char buffer[cmd.arg1];
            read(sock, &buffer, sizeof(buffer));
            ret = write(cmd.fd, &buffer, sizeof(buffer));
            send_reponse(sock, 0, ret);
        }
            break;
        case FSMSG_READ:
        {
            recv(sock, &cmd, sizeof(cmd), MSG_WAITALL);
            printf("received FSMSG_READ, fd = %i\n", cmd.fd);
		 
            char buffer[cmd.arg1];
            read_bytes = read(cmd.fd, &buffer, sizeof(buffer));
            write(sock, &buffer, sizeof(buffer));
            send_reponse(sock, 0, read_bytes);
        }
            break;
        case FSMSG_LSEEK:
            recv(sock, &cmd, sizeof(cmd), MSG_WAITALL);
            printf("received FSMSG_LSEEK, fd = %i\n", cmd.fd);
		 
            ret = lseek(cmd.fd, cmd.arg1, cmd.arg2);
            send_reponse(sock, 0, ret);
            
            break;
        case FSMSG_CLOSE:
            recv(sock, &cmd, sizeof(cmd), MSG_WAITALL);
            printf("received FSMSG_CLOSE, fd = %i\n", cmd.fd);

            ret = close(cmd.fd);
            send_reponse(sock, 0, ret);
            
            break;
        case FSMSG_STAT:
            recv(sock, &cmd, sizeof(cmd), MSG_WAITALL);
            printf("received FSMSG_STAT, fd = %i\n", cmd.fd);

            struct stat sb;
            ret = fstat(cmd.fd, &sb);
            send_stat_reponse(sock, 0, ret, &sb);
            
            break;
        default:
            printf("unknown msg type %d\n", cmd_type);
            return 1;
        }
    }

    printf("subprocess exiting\n");
    return 0;
}