Subversion Repositories HelenOS

/** @addtogroup sctrace

 * @{

 */

/** @file

 */

#include <stdio.h>

#include <stdlib.h>

#include <libadt/hash_table.h>

#include "ipc_desc.h"

#include "proto.h"

#include "ipcp.h"

#define IPCP_CALLID_SYNC 0

typedef struct {

    int phone_hash;

    ipc_call_t question;

    int call_hash;

    link_t link;

} pending_call_t;

typedef struct {

    int server;

    proto_t *proto;

} connection_t;

#define MAX_PHONE 64

connection_t connections[MAX_PHONE];

int have_conn[MAX_PHONE];

#define PCALL_TABLE_CHAINS 32

hash_table_t pending_calls;

hash_index_t pending_call_hash(unsigned long key[])

{

//  printf("pending_call_hash\n");

    return key[0] % PCALL_TABLE_CHAINS;

}

int pending_call_compare(unsigned long key[], hash_count_t keys,

    link_t *item)

{

    pending_call_t *hs;

//  printf("pending_call_compare\n");

    hs = hash_table_get_instance(item, pending_call_t, link);

    return key[0] == hs->call_hash;

}

void pending_call_remove_callback(link_t *item)

{

//  printf("pending_call_remove_callback\n");

}

hash_table_operations_t pending_call_ops = {

    .hash = pending_call_hash,

    .compare = pending_call_compare,

    .remove_callback = pending_call_remove_callback

};

void ipcp_connection_set(int phone, int server, proto_t *proto)

{

    if (phone <0 || phone >= MAX_PHONE) return;

    connections[phone].server = server;

    connections[phone].proto = proto;

    have_conn[phone] = 1;

}

void ipcp_connection_clear(int phone)

{

    have_conn[phone] = 0;

    connections[phone].server = 0;

    connections[phone].proto = NULL;

}

static void ipc_m_print(proto_t *proto, ipcarg_t method)

{

    ipc_m_desc_t *desc;

    oper_t *oper;

    /* FIXME: too slow */

    desc = ipc_methods;

    while (desc->number != 0) {

        if (desc->number == method) {

            printf("%s (%d)", desc->name, method);

            return;

        }

        ++desc;

    }

    if (proto != NULL) {

        oper = proto_get_oper(proto, method);

        if (oper != NULL) {

            printf("%s (%d)", oper->name, method);

            return;

        }

    }

    printf("%d", method);

}

void ipcp_init(void)

{

    hash_table_create(&pending_calls, PCALL_TABLE_CHAINS, 1, &pending_call_ops);

}

void ipcp_cleanup(void)

{

    hash_table_destroy(&pending_calls);

}

void ipcp_call_out(int phone, ipc_call_t *call, ipc_callid_t hash)

{

    pending_call_t *pcall;

    proto_t *proto;

    if (have_conn[phone]) proto = connections[phone].proto;

    else proto = NULL;

//  printf("ipcp_call_out()\n");

    printf("call id: 0x%x, phone: %d, proto: %s, method: ", hash, phone,

        (proto ? proto->name : "n/a"));

    ipc_m_print(proto, IPC_GET_METHOD(*call));

    printf(" args: (%u, %u, %u, %u, %u)\n",

        IPC_GET_ARG1(*call),

        IPC_GET_ARG2(*call),

        IPC_GET_ARG3(*call),

        IPC_GET_ARG4(*call),

        IPC_GET_ARG5(*call)

    );

    /* Store call in hash table for response matching */

    pcall = malloc(sizeof(pending_call_t));

    pcall->phone_hash = phone;

    pcall->question = *call;

    pcall->call_hash = hash;

    hash_table_insert(&pending_calls, &pcall->call_hash, &pcall->link);

}

static void parse_answer(pending_call_t *pcall, ipc_call_t *answer)

{

    int phone;

    ipcarg_t method;

    ipcarg_t service;

    int retval;

    static proto_t proto_unknown = { .name = "unknown" };

    proto_t *proto;

    int cphone;

//  printf("parse_answer\n");

    phone = pcall->phone_hash;

    method = IPC_GET_METHOD(pcall->question);

    retval = IPC_GET_RETVAL(*answer);

    printf("phone=%d, method=%d, retval=%d\n",

        phone, method, retval);

    if (phone == 0 && method == IPC_M_CONNECT_ME_TO && retval == 0) {

        /* Connected to a service (through NS) */

        service = IPC_GET_ARG1(pcall->question);

        proto = proto_get_by_srv(service);

        if (proto == NULL) proto = &proto_unknown;

        cphone = IPC_GET_ARG5(*answer);

        printf("registering connection (phone %d, protocol: %s)\n", cphone,

            proto->name);

        ipcp_connection_set(cphone, 0, proto);

    }

}

void ipcp_call_in(ipc_call_t *call, ipc_callid_t hash)

{

    link_t *item;

    pending_call_t *pcall;

//  printf("ipcp_call_in()\n");

/*  printf("phone: %d, method: ", call->in_phone_hash);

    ipc_m_print(IPC_GET_METHOD(*call));

    printf(" args: (%u, %u, %u, %u, %u)\n",

        IPC_GET_ARG1(*call),

        IPC_GET_ARG2(*call),

        IPC_GET_ARG3(*call),

        IPC_GET_ARG4(*call),

        IPC_GET_ARG5(*call)

    );*/

    if ((hash & IPC_CALLID_ANSWERED) == 0 && hash != IPCP_CALLID_SYNC) {

        /* Not a response */

        printf("Not a response (hash %d)\n", hash);

        return;

    }

    hash = hash & ~IPC_CALLID_ANSWERED;

    item = hash_table_find(&pending_calls, &hash);

    if (item == NULL) return; // No matching question found

    pcall = hash_table_get_instance(item, pending_call_t, link);

    printf("response matched to question\n");

    hash_table_remove(&pending_calls, &hash, 1);

    parse_answer(pcall, call);

    free(pcall);

}

void ipcp_call_sync(int phone, ipc_call_t *call, ipc_call_t *answer)

{

    ipcp_call_out(phone, call, IPCP_CALLID_SYNC);

    ipcp_call_in(answer, IPCP_CALLID_SYNC);

}

void ipcp_hangup(int phone, int rc)

{

    printf("hangup phone %d -> %d\n", phone, rc);

    ipcp_connection_clear(phone);

}

/** @}

 */