/*
 * Copyright 2012 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Paweł Dziepak, pdziepak@quarnos.org
 */


#include "Delegation.h"

#include "Inode.h"
#include "Request.h"


Delegation::Delegation(const OpenDelegationData& data, Inode* inode,
        uint64 clientID, bool attribute)
        :
        fClientID(clientID),
        fData(data),
        fInode(inode),
        fAttribute(attribute),
        fStateSeq(data.fStateSeq),
        fUid(geteuid()),
        fGid(getegid()),
        fRecalled(false)
{
        ASSERT(inode != NULL);
        memcpy(fStateID, data.fStateID, sizeof(fStateID));
}


status_t
Delegation::GiveUp(bool truncate)
{
        PrepareGiveUp(truncate);

        return DoGiveUp(truncate);
}


status_t
Delegation::PrepareGiveUp(bool truncate)
{
        status_t status = B_OK;
        if (!fAttribute && !truncate)
                status = fInode->Sync(true, false);

        return status;
}


status_t
Delegation::DoGiveUp(bool truncate, bool wait)
{
        if (!fAttribute && !truncate && wait)
                fInode->WaitAIOComplete();

        status_t status = ReturnDelegation();

        fInode->Commit(fUid, fGid);

        return status;
}


void
Delegation::GetStateIDandSeq(uint32* stateID, uint32& stateSeq) const
{
        memcpy(stateID, fStateID, sizeof(uint32) * 3);
        stateSeq = fStateSeq;
}


void
Delegation::Dump(void (*xprintf)(const char*, ...)) const
{
        xprintf("Delegation at %p for Inode at %p (ino %" B_PRIdINO ")\n", this, fInode, fInode->ID());
        if (fData.fType == OPEN_DELEGATE_READ)
                xprintf("\ttype OPEN_DELEGATE_READ, ");
        else if (fData.fType == OPEN_DELEGATE_WRITE)
                xprintf("\ttype OPEN_DELEGATE_WRITE, ");
        xprintf("attribute %d, uid %" B_PRIu32 ", gid %" B_PRIu32 "\n", fAttribute, fUid, fGid);
        xprintf("\tstate id and sequence %" B_PRIu32 " %" B_PRIu32 " %" B_PRIu32 " %" B_PRIu32 "\n",
                fData.fStateID[0], fData.fStateID[1], fData.fStateID[2], fData.fStateSeq);

        return;
}


status_t
Delegation::ReturnDelegation()
{
        uint32 attempt = 0;
        do {
                RPC::Server* serv = fFileSystem->Server();
                Request request(serv, fFileSystem, fUid, fGid);
                RequestBuilder& req = request.Builder();

                req.PutFH(fInfo.fHandle);
                req.DelegReturn(fData.fStateID, fData.fStateSeq);

                status_t result = request.Send();
                if (result != B_OK)
                        return result;

                ReplyInterpreter& reply = request.Reply();

                if (HandleErrors(attempt, reply.NFS4Error(), serv, NULL,
                                fInode->GetOpenState())) {
                        continue;
                }

                reply.PutFH();

                return reply.DelegReturn();
        } while (true);
}