/*
**==============================================================================
**
** Open Management Infrastructure (OMI)
**
** Copyright (c) Microsoft Corporation
** 
** Licensed under the Apache License, Version 2.0 (the "License"); you may not 
** use this file except in compliance with the License. You may obtain a copy 
** of the License at 
**
**     http://www.apache.org/licenses/LICENSE-2.0 
**
** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED 
** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
** MERCHANTABLITY OR NON-INFRINGEMENT. 
**
** See the Apache 2 License for the specific language governing permissions 
** and limitations under the License.
**
**==============================================================================
*/

#include <base/strings.h>
#include <base/messages.h>
#include <base/log.h>
#include <base/strings.h>
#include <base/paths.h>
#include <base/io.h>
#include <protocol/protocol.h>
#include "agentmgr.h"

#if defined(CONFIG_POSIX)
# include <unistd.h>
# include <errno.h>
# include <sys/socket.h>
# include <netinet/tcp.h>
# include <netinet/in.h>
# include <sys/time.h>
# include <sys/types.h>
# include <netdb.h>
# include <fcntl.h>
# include <arpa/inet.h>
# include <signal.h>
# include <sys/wait.h>
#endif

#define T MI_T

/*
**==============================================================================
**
** Data structures
**
**==============================================================================
*/

#if defined(CONFIG_POSIX)

typedef struct _RequestItem RequestItem;
/*
    RequestItem - stores information about request sent to the agent/provider;
    this item stores original request's msgID (has to be substituted) and request pointer
    In case of agent disconnection, agent-mgr uses this list to send error responses to 
    outstanding requests.
*/
struct _RequestItem
{
    /* Linked-list support */
    RequestItem* next;
    RequestItem* prev;

    Message* request;
    MI_Uint64 originalMsgID;
};

/*
    AgentElem - stores information about single running agent
*/
struct _AgentElem
{
    /* Linked-list support */
    AgentElem* next;
    AgentElem* prev;

    /* outstanding requests */
    RequestItem* headRequests;
    RequestItem* tailRequests;

    /* hosting context */
    uid_t uid;
    gid_t gid;

    /* connection to the agent */
    Protocol*   protocol;

    /* link to manager */
    AgentMgr*   agentMgr;

    /* agent process pid */
    pid_t       agentPID;
};

/*
**==============================================================================
**
** Local functions
**
**==============================================================================
*/
static AgentElem* _FindAgent(
    AgentMgr* self,
    uid_t uid,
    gid_t gid)
{
    AgentElem* agent;

    agent = self->headAgents;

    while (agent)
    {
        if (uid == agent->uid && gid == agent->gid)
            return agent;

        agent = agent->next;
    }
    return 0;
}

static pid_t _SpawnAgentProcess(
    Sock s,
    int logfd,
    uid_t uid,
    gid_t gid,
    const char* provDir,
    MI_Uint32 idletimeout)
{
    pid_t child;
    int fdLimit;
    int fd;
    char param_sock[32];
    char param_logfd[32];
    char param_idletimeout[32];

    child = fork();

    if (child < 0)
        return -1;  /* Failed */

    if (child > 0)
        return child;   /* Started */

    /* We are in child process here */

    /* switch user */
    if (0 != SetUser(uid,gid))
    {
        _exit(1);
    }

    /* Close all open file descriptors except provided socket
     (Some systems have UNLIMITED of 2^64; limit to something reasonable) */

    fdLimit = getdtablesize();
    if (fdLimit > 2500 || fdLimit < 0)
    {
        fdLimit = 2500;
    }

    /* ATTN: close first 3 also! Left for debugging only */
    for (fd = 3; fd < fdLimit; ++fd)
    {
        if (fd != s && fd != logfd)
            close(fd);
    }

    /* prepare parameter:
        socket fd to attach */
    Snprintf(param_sock, sizeof(param_sock), "%d", (int)s);
    Snprintf(param_logfd, sizeof(param_logfd), "%d", (int)logfd);
    Snprintf(param_idletimeout, sizeof(param_idletimeout), "%d", (int)idletimeout);

    execl(GetPath(ID_AGENTPROGRAM), 
        GetPath(ID_AGENTPROGRAM), 
        param_sock,
        param_logfd,
        "--destdir",
        GetPath(ID_DESTDIR),
        "--providerdir",
        provDir,
        "--idletimeout",
        param_idletimeout,
        "--loglevel",
        Log_GetLevelString(Log_GetLevel()),
        NULL);

    LOGW_CHAR(("agent launching: failed to exec %s, errno %d\n", 
        GetPath(ID_AGENTPROGRAM),
        errno));
    _exit(1); 
    return -1;  /* never get here */
}

static void _SendErrorResponse(
    RequestItem* requestItem,
    MI_Result r)
{
    PostResultMsg* resp;

    resp = PostResultMsg_New( requestItem->originalMsgID );

    if (!resp)
        return;

    requestItem->request->msgID = requestItem->originalMsgID;
    resp->base.clientID = requestItem->request->clientID;

    resp->result = r;
    Message_SetRequest(&resp->base,requestItem->request);
    (*requestItem->request->callback)(&resp->base, requestItem->request->callbackData);

    PostResultMsg_Release(resp);
}

static void _FreeItem(
    AgentElem*agent)
{
    /* send error repsonses to all outstanding requests */
    while (agent->headRequests)
    {
        RequestItem* requestItem = agent->headRequests;

        _SendErrorResponse(requestItem, MI_RESULT_FAILED);

        /* free item from list */
        List_Remove(
            (ListElem**)&agent->headRequests, 
            (ListElem**)&agent->tailRequests, 
            (ListElem*)requestItem);

        /* Note:
            request item was allocated form message's batch so no need to free it directly;
            Message's release may free batch and invalidate requestItem */
        Message_Release(requestItem->request);
    }

    if (agent->protocol)
        Protocol_Delete(agent->protocol);

    /* SIGCHILD HANDLER will take care of pid waiting */
    /*if (agent->agentPID > 0)
    {
        int loc = 0;
        pid_t p = waitpid(agent->agentPID, &loc, WNOHANG);

        LOGI_CHAR(("waitpid returned %d, loc %d",(int)p, loc));

        if (p != agent->agentPID)
        {
            kill(agent->agentPID, SIGKILL);
            p = waitpid(agent->agentPID, &loc, WNOHANG);

            LOGW_CHAR(("sent KILL; waitpid returned %d, loc %d",(int)p, loc));
        }
    }*/

    free(agent);
}

static void _EventCallback(
    Protocol* protocol,
    ProtocolEvent event,
    void* data)
{
    AgentElem* agent = (AgentElem*)data;

    MI_UNUSED(protocol);
    MI_UNUSED(event);

    DEBUG_ASSERT(PROTOCOLEVENT_DISCONNECT == event);


    LOGW_CHAR(("lost connection to agent running as [%d]", (int)agent->uid));
    /* lost connection to the agent:
        - send error repsonses to all outstanding requests ( within 'FreeItem' call)
        - remove agent form the list
    */

    /* remove agent from Mgr's list */
    List_Remove(
        (ListElem**)&agent->agentMgr->headAgents, 
        (ListElem**)&agent->agentMgr->tailAgents, 
        (ListElem*)agent);

    _FreeItem(agent);
}

static MI_Boolean _RequestCallback(
    Protocol* protocol_,
    Message* msg,
    void* data)
{
    AgentElem* self = (AgentElem*)data;
    RequestItem* requestItem;

    MI_UNUSED(protocol_);

    /* ATTN: verify unload message */
    if (BinProtocolNotificationTag == msg->tag)
    {
        BinProtocolNotification* notification = (BinProtocolNotification*)msg;
        if (BinNotificationAgentIdle == notification->type)
        {
            /* Check if this agnet has outstanding requests -
                if agent is idle, return false form callback 
                to close connection to it.
                It will forces protocl to close conneciton and send
                'disconnect' event to event-callback
                */
            if (self->headRequests)
                return MI_TRUE;
            else
                return MI_FALSE;
        }
        /* ignore service messages */
        return MI_TRUE;
    }


    /* get/verify request-item */
    requestItem = (RequestItem*)Uint64ToPtr(msg->msgID);

    /* ATTN: add verification if element is in list to prevent incorect pointer attack */
    {
        RequestItem* cur = self->headRequests;

        while (cur)
        {
            if (cur == requestItem)
                break;

            cur = cur->next;
        }

        if (cur != requestItem)
        {
            LOGE_CHAR(("cannot find request item %p; agent for user %d!\n", requestItem, (int)self->uid));
            return MI_FALSE;
        }
    }

    /* restore msgID */
    requestItem->request->msgID = requestItem->originalMsgID;
    msg->msgID = requestItem->originalMsgID;
    msg->clientID = requestItem->request->clientID;

    /* Attach request and post repsonse */
    Message_SetRequest(msg,requestItem->request);
    (*requestItem->request->callback)(msg, requestItem->request->callbackData);

    /* remove item if result received */
    if (msg->tag == PostResultMsgTag)
    {
        List_Remove(
            (ListElem**)&self->headRequests, 
            (ListElem**)&self->tailRequests, 
            (ListElem*)requestItem);

        /* Note:
            request item was allocated form message's batch so no need to free it directly;
            Message's release may free batch and invalidate requestItem */
        Message_Release(requestItem->request);
    }

    return MI_TRUE;
}

static AgentElem* _CreateAgent(
    AgentMgr* self,
    uid_t uid,
    gid_t gid)
{
    AgentElem* agent = 0;
    Sock s[2];
    int logfd = -1;


    /* create communication pipe */
    if(0 != socketpair(AF_UNIX, SOCK_STREAM, 0, s))
    {
        LOGW_CHAR(("socketpair() failed\n"));
        return 0;
    }

    if (MI_RESULT_OK != Sock_SetBlocking(s[0], MI_FALSE) ||
        MI_RESULT_OK != Sock_SetBlocking(s[1], MI_FALSE))
    {
        LOGW_CHAR(("set non-blocking failed\n"));
        goto failed;
    }

    /* create/open log file for agent */
    {
        char path[MAX_PATH_SIZE];

        if (0 != FormatLogFileName(uid, gid, path))
        {
            LOGW_CHAR(("cannot format log file name\n"));
            goto failed;
        }

        /* Create/open fiel with permisisons 644 */
        logfd = open(path, O_WRONLY|O_CREAT|O_APPEND, S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
        if (logfd == -1)
        {
            LOGW_CHAR(("failed to create log file %s; errno %d", path, (int)errno));
            goto failed;
        }
    }

    agent = (AgentElem*)calloc(1, sizeof(*agent));

    if (!agent)
        goto failed;

    agent->agentMgr = self;
    agent->uid = uid;
    agent->gid = gid;

    if ((agent->agentPID = 
        _SpawnAgentProcess(
            s[0], 
            logfd, 
            uid, 
            gid, 
            self->provDir, 
            (MI_Uint32)(self->provmgr.idleTimeoutUsec / 1000000))) < 0)
    {
        LOGW_CHAR(("cannot spawn a child process\n"));
        goto failed;
    }

    close(logfd);
    logfd = -1;

    /* Close socket 0 - it will be used by child process */
    Sock_Close(s[0]);
    s[0] = INVALID_SOCK;

    if (MI_RESULT_OK != Protocol_New_From_Socket(
        &agent->protocol,
        self->selector,
        s[1],
        MI_TRUE,
        _RequestCallback,
        agent,
        _EventCallback,
        agent))
            goto failed;

    s[1] = INVALID_SOCK;

    List_Append(
        (ListElem**)&self->headAgents, 
        (ListElem**)&self->tailAgents, 
        (ListElem*)agent);

    return agent;

failed:
    if (INVALID_SOCK != s[0]) 
        Sock_Close(s[0]);

    if (INVALID_SOCK != s[1]) 
        Sock_Close(s[1]);

    if (-1 != logfd) 
        close(logfd);

    if (agent)
        _FreeItem(agent);

    return 0;
}

static AgentElem* _FindOrCreateAgent(
    AgentMgr* self,
    uid_t uid,
    gid_t gid)
{
    AgentElem* agent = _FindAgent(self, uid, gid);

    if (!agent)
        agent = _CreateAgent(self, uid, gid);

    return agent;
}

static MI_Result _SendMessageToAgent(
    AgentElem* agent,
    Message* msg,
    const ProvRegEntry* proventry)
{
    RequestItem* newRequestItem;
    Message* req = 0;
    MI_Result r;

    /* Allocate item form incoming message batch */ 
    newRequestItem = (RequestItem*) Batch_GetClear(msg->batch, sizeof(*newRequestItem));

    if (!newRequestItem)
        return MI_RESULT_FAILED;

    newRequestItem->request = msg;

    /* clone message (may be incoming message in some cases) */
    if (MI_RESULT_OK != MessagePackCloneForBinarySending(msg, &req))
    {
        LOGW_CHAR(("message clone failed\n"));
        return MI_RESULT_FAILED;
    }

    req->libraryName = Batch_Strdup2(req->batch, proventry->libraryName);

    if (!req->libraryName)
    {
        Message_Release(req);
        return MI_RESULT_FAILED;
    }
    
    /* Add ref to keep request around until Result received */
    Message_AddRef(msg);

    newRequestItem->originalMsgID = msg->msgID;

    /* substitute message-id on time server->agent call;
    msgID has to be restored once first response is received */
    req->msgID = PtrToUint64(newRequestItem);

    List_Append(
        (ListElem**)&agent->headRequests, 
        (ListElem**)&agent->tailRequests, 
        (ListElem*)newRequestItem);

    r =  Protocol_Send(agent->protocol, req);
    Message_Release(req);

    return r;
}

#endif

/*
**==============================================================================
**
** Public API
**
**==============================================================================
*/
MI_Result AgentMgr_Init(
    AgentMgr* self,
    Selector* selector)
{
    /* Check parameters */
    if (!self)
        return MI_RESULT_INVALID_PARAMETER;

    memset(self, 0, sizeof(*self));

    /* Initialize the provider manager */
    MI_RETURN_ERR(ProvMgr_Init(&self->provmgr, selector, NULL, NULL, GetPath(ID_PROVIDERDIR)));

    self->home = Strdup(GetPath(ID_PREFIX));
    self->provDir = Strdup(GetPath(ID_PROVIDERDIR));

    self->selector = selector;

    return MI_RESULT_OK;
}

MI_Result AgentMgr_Destroy(
    AgentMgr* self)
{
    ProvMgr_Destroy(&self->provmgr);
    free(self->home);
    free(self->provDir);

#if defined(CONFIG_POSIX)
    /*
        Free all outstanding agents
    */
    while (self->headAgents)
    {
        AgentElem* agent = self->headAgents;

        List_Remove(
            (ListElem**)&self->headAgents, 
            (ListElem**)&self->tailAgents, 
            (ListElem*)agent);

        _FreeItem(agent);
    }
#endif

    /* Invalidate self */
    memset(self, 0xdd, sizeof(*self));

    return MI_RESULT_OK;
}

MI_Result AgentMgr_HandleRequest(
    AgentMgr* self,
    Message* msg,
    const ProvRegEntry* proventry)
{
    AgentElem* agent;
    uid_t uid;
    gid_t gid;

    if (proventry->hosting == PROV_HOSTING_INPROC)
        return ProvMgr_PostMessage(
            &self->provmgr,
            proventry->libraryName,
            msg);

    if (proventry->hosting == PROV_HOSTING_USER)
    {
        if (0 != LookupUser(proventry->user, &uid, &gid))
        {
            LOGW_CHAR(("get user [%s] uid/gid", proventry->user ));
            return MI_RESULT_FAILED;
        }
    }
    else
    {
        uid = msg->uid;
        gid = msg->gid;
    }

#if defined(CONFIG_POSIX)

    agent = _FindOrCreateAgent(self, uid, gid);

    if (!agent)
        return MI_RESULT_FAILED;

    return _SendMessageToAgent(agent, msg, proventry);
#else
    MI_UNUSED(agent);
    /* windows version hosts all providers as 'in-proc' */
    return ProvMgr_PostMessage(
            &self->provmgr,
            proventry->libraryName,
            msg);
#endif
}