コード例 #1
0
ファイル: srv_pipe_hnd.c プロジェクト: AllardJ/Tomato
static void *make_internal_rpc_pipe_p(char *pipe_name, 
			      connection_struct *conn, uint16 vuid)
{
	pipes_struct *p;
	user_struct *vuser = get_valid_user_struct(vuid);

	DEBUG(4,("Create pipe requested %s\n", pipe_name));

	if (!vuser && vuid != UID_FIELD_INVALID) {
		DEBUG(0,("ERROR! vuid %d did not map to a valid vuser struct!\n", vuid));
		return NULL;
	}

	p = SMB_MALLOC_P(pipes_struct);

	if (!p) {
		DEBUG(0,("ERROR! no memory for pipes_struct!\n"));
		return NULL;
	}

	ZERO_STRUCTP(p);

	if ((p->mem_ctx = talloc_init("pipe %s %p", pipe_name, p)) == NULL) {
		DEBUG(0,("open_rpc_pipe_p: talloc_init failed.\n"));
		SAFE_FREE(p);
		return NULL;
	}

	if ((p->pipe_state_mem_ctx = talloc_init("pipe_state %s %p", pipe_name, p)) == NULL) {
		DEBUG(0,("open_rpc_pipe_p: talloc_init failed.\n"));
		talloc_destroy(p->mem_ctx);
		SAFE_FREE(p);
		return NULL;
	}

	if (!init_pipe_handle_list(p, pipe_name)) {
		DEBUG(0,("open_rpc_pipe_p: init_pipe_handles failed.\n"));
		talloc_destroy(p->mem_ctx);
		talloc_destroy(p->pipe_state_mem_ctx);
		SAFE_FREE(p);
		return NULL;
	}

	/*
	 * Initialize the incoming RPC data buffer with one PDU worth of memory.
	 * We cheat here and say we're marshalling, as we intend to add incoming
	 * data directly into the prs_struct and we want it to auto grow. We will
	 * change the type to UNMARSALLING before processing the stream.
	 */

	if(!prs_init(&p->in_data.data, RPC_MAX_PDU_FRAG_LEN, p->mem_ctx, MARSHALL)) {
		DEBUG(0,("open_rpc_pipe_p: malloc fail for in_data struct.\n"));
		talloc_destroy(p->mem_ctx);
		talloc_destroy(p->pipe_state_mem_ctx);
		close_policy_by_pipe(p);
		SAFE_FREE(p);
		return NULL;
	}

	DLIST_ADD(InternalPipes, p);

	p->conn = conn;

	p->vuid  = vuid;

	p->endian = RPC_LITTLE_ENDIAN;

	ZERO_STRUCT(p->pipe_user);

	p->pipe_user.ut.uid = (uid_t)-1;
	p->pipe_user.ut.gid = (gid_t)-1;
	
	/* Store the session key and NT_TOKEN */
	if (vuser) {
		p->session_key = data_blob(vuser->session_key.data, vuser->session_key.length);
		p->pipe_user.nt_user_token = dup_nt_token(
			NULL, vuser->nt_user_token);
	}

	/*
	 * Initialize the outgoing RPC data buffer with no memory.
	 */	
	prs_init(&p->out_data.rdata, 0, p->mem_ctx, MARSHALL);
	
	fstrcpy(p->name, pipe_name);
	
	DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
		 pipe_name, pipes_open));

	return (void*)p;
}
コード例 #2
0
ファイル: srv_pipe_hnd.c プロジェクト: gojdic/samba
static struct pipes_struct *make_internal_rpc_pipe_p(TALLOC_CTX *mem_ctx,
        const struct ndr_syntax_id *syntax,
        const char *client_address,
        struct auth_serversupplied_info *server_info)
{
    pipes_struct *p;

    DEBUG(4,("Create pipe requested %s\n",
             get_pipe_name_from_iface(syntax)));

    p = TALLOC_ZERO_P(mem_ctx, struct pipes_struct);

    if (!p) {
        DEBUG(0,("ERROR! no memory for pipes_struct!\n"));
        return NULL;
    }

    if ((p->mem_ctx = talloc_init("pipe %s %p",
                                  get_pipe_name_from_iface(syntax),
                                  p)) == NULL) {
        DEBUG(0,("open_rpc_pipe_p: talloc_init failed.\n"));
        TALLOC_FREE(p);
        return NULL;
    }

    if (!init_pipe_handle_list(p, syntax)) {
        DEBUG(0,("open_rpc_pipe_p: init_pipe_handles failed.\n"));
        talloc_destroy(p->mem_ctx);
        TALLOC_FREE(p);
        return NULL;
    }

    /*
     * Initialize the incoming RPC data buffer with one PDU worth of memory.
     * We cheat here and say we're marshalling, as we intend to add incoming
     * data directly into the prs_struct and we want it to auto grow. We will
     * change the type to UNMARSALLING before processing the stream.
     */

    if(!prs_init(&p->in_data.data, 128, p->mem_ctx, MARSHALL)) {
        DEBUG(0,("open_rpc_pipe_p: malloc fail for in_data struct.\n"));
        talloc_destroy(p->mem_ctx);
        close_policy_by_pipe(p);
        TALLOC_FREE(p);
        return NULL;
    }

    p->server_info = copy_serverinfo(p, server_info);
    if (p->server_info == NULL) {
        DEBUG(0, ("open_rpc_pipe_p: copy_serverinfo failed\n"));
        talloc_destroy(p->mem_ctx);
        close_policy_by_pipe(p);
        TALLOC_FREE(p);
        return NULL;
    }

    DLIST_ADD(InternalPipes, p);

    memcpy(p->client_address, client_address, sizeof(p->client_address));

    p->endian = RPC_LITTLE_ENDIAN;

    /*
     * Initialize the outgoing RPC data buffer with no memory.
     */
    prs_init_empty(&p->out_data.rdata, p->mem_ctx, MARSHALL);

    p->syntax = *syntax;

    DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
             get_pipe_name_from_iface(syntax), pipes_open));

    talloc_set_destructor(p, close_internal_rpc_pipe_hnd);

    return p;
}
コード例 #3
0
ファイル: srv_pipe_hnd.c プロジェクト: niubl/camera_project
static void *make_internal_rpc_pipe_p(char *pipe_name, 
			      connection_struct *conn, uint16 vuid)
{
	pipes_struct *p;
	user_struct *vuser = get_valid_user_struct(vuid);

	DEBUG(4,("Create pipe requested %s\n", pipe_name));

	if (!vuser && vuid != UID_FIELD_INVALID) {
		DEBUG(0,("ERROR! vuid %d did not map to a valid vuser struct!\n", vuid));
		return NULL;
	}

	p = (pipes_struct *)malloc(sizeof(*p));

	if (!p)
	{
		DEBUG(0,("ERROR! no memory for pipes_struct!\n"));
		return NULL;
	}

	ZERO_STRUCTP(p);

	if ((p->mem_ctx = talloc_init("pipe %s %p", pipe_name, p)) == NULL) {
		DEBUG(0,("open_rpc_pipe_p: talloc_init failed.\n"));
		SAFE_FREE(p);
		return NULL;
	}

	if (!init_pipe_handle_list(p, pipe_name)) {
		DEBUG(0,("open_rpc_pipe_p: init_pipe_handles failed.\n"));
		talloc_destroy(p->mem_ctx);
		SAFE_FREE(p);
		return NULL;
	}

	/*
	 * Initialize the incoming RPC data buffer with one PDU worth of memory.
	 * We cheat here and say we're marshalling, as we intend to add incoming
	 * data directly into the prs_struct and we want it to auto grow. We will
	 * change the type to UNMARSALLING before processing the stream.
	 */

	if(!prs_init(&p->in_data.data, MAX_PDU_FRAG_LEN, p->mem_ctx, MARSHALL)) {
		DEBUG(0,("open_rpc_pipe_p: malloc fail for in_data struct.\n"));
		return NULL;
	}

	DLIST_ADD(InternalPipes, p);

	p->conn = conn;

	/* Ensure the connection isn't idled whilst this pipe is open. */
	p->conn->num_files_open++;

	p->vuid  = vuid;

	p->ntlmssp_chal_flags = 0;
	p->ntlmssp_auth_validated = False;
	p->ntlmssp_auth_requested = False;

	p->pipe_bound = False;
	p->fault_state = False;
	p->endian = RPC_LITTLE_ENDIAN;

	ZERO_STRUCT(p->pipe_user);

	p->pipe_user.uid = (uid_t)-1;
	p->pipe_user.gid = (gid_t)-1;
	
	/* Store the session key and NT_TOKEN */
	if (vuser) {
		p->session_key = data_blob(vuser->session_key.data, vuser->session_key.length);
		p->pipe_user.nt_user_token = dup_nt_token(vuser->nt_user_token);
	}

	/*
	 * Initialize the incoming RPC struct.
	 */

	p->in_data.pdu_needed_len = 0;
	p->in_data.pdu_received_len = 0;

	/*
	 * Initialize the outgoing RPC struct.
	 */

	p->out_data.current_pdu_len = 0;
	p->out_data.current_pdu_sent = 0;
	p->out_data.data_sent_length = 0;

	/*
	 * Initialize the outgoing RPC data buffer with no memory.
	 */	
	prs_init(&p->out_data.rdata, 0, p->mem_ctx, MARSHALL);
	
	fstrcpy(p->name, pipe_name);
	
	DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
		 pipe_name, pipes_open));

	return (void*)p;
}