Beispiel #1
0
LIB_EXPORT
rc_t CC
XFSNodeRelease ( const struct XFSNode * self )
{
    rc_t RCt;
    int RefC;

    RCt = 0;
    RefC = 0;

    if ( self != NULL ) {
/*
pLogMsg ( klogDebug, "XFSNodeRelease ( $(node) )[$(name)]", "node=%p,name=%s", ( void * ) self, self -> Name );
*/
        RefC = KRefcountDrop (
                            & ( self -> refcount ),
                            _sXFSNode_classname
                            );
        switch ( RefC ) {
            case krefOkay :
            case krefZero :     RCt = 0; break;

            case krefWhack :    RCt = XFSNodeDispose ( self ); break;

            case krefNegative : RCt = XFS_RC ( rcInvalid ); break;
            default :           RCt = XFS_RC ( rcUnknown ); break;
        }
    }

    return RCt;
}   /* XFSNodeRelease () */
Beispiel #2
0
static
rc_t CC
_KartCollectionNodeConstructorEx (
                        const struct XFSModel * Model,
                        const struct XFSModelNode * Template,
                        const char * Alias,
                        XFSNType Type,
                        const struct XFSNode ** Node
)
{
    rc_t RCt;
    struct XFSNode * TheNode;
    const char * NodeName;
    const char * Path;

    RCt = 0;
    TheNode = NULL;
    NodeName = NULL;
    Path = NULL;

    if ( Model == NULL || Template == NULL || Node == NULL ) {
        return XFS_RC ( rcNull );
    }

    * Node = NULL;

    NodeName = Alias == NULL ? XFSModelNodeName ( Template ) : Alias;

    Path = XFSModelNodeProperty ( Template, XFS_MODEL_SOURCE );
    if ( Path != NULL ) {
        RCt = XFSKartCollectionNodeMake (
                                    NodeName,
                                    Path,
                                    XFSModelNodeSecurity ( Template ),
                                    & TheNode
                                    );
    }
    else {
        RCt = _KartCollectionNodeMakeFromModel (
                                            NodeName,
                                            Model,
                                            Template,
                                            & TheNode
                                            );
    }

    if ( RCt == 0 ) {
        * Node = TheNode;
    }
    else {
        * Node = NULL;

        if ( TheNode != NULL ) {
            XFSNodeDispose ( TheNode );
        }
    }

    return RCt;
}   /* _KartCollectionNodeConstructorEx () */
Beispiel #3
0
LIB_EXPORT
rc_t CC
XFSGapKartNodeMake (
            struct XFSNode ** Node,
            const char * Name,
            uint32_t ProjectId,
            const char * Perm
)
{
    rc_t RCt;
    struct XFSKartNode * KartNode;

    RCt = 0;
    KartNode = NULL;


    XFS_CSAN ( Node )
    XFS_CAN ( Node )
    XFS_CAN ( Name )

    KartNode = calloc ( 1, sizeof ( struct XFSKartNode ) );
    if ( KartNode == NULL ) {
        RCt = XFS_RC ( rcExhausted );
    }
    else {
        RCt = XFSContNodeInit (
                            & ( KartNode -> node . node ),
                            Name,
                            Perm,
                            _sFlavorOfGapKart,
                            _KartNodeDispose
                            );
        if ( RCt == 0 ) {
            KartNode -> project_id = ProjectId;

            RCt = _LoadKart ( KartNode );
            if ( RCt == 0 ) {
                * Node = ( struct XFSNode * ) KartNode;
            }
        }
    }

    if ( RCt != 0 ) {
        * Node = NULL;

        if ( KartNode != NULL ) {
            XFSNodeDispose ( & ( KartNode -> node . node ) );
            KartNode = NULL;
        }
    }

/*
pLogMsg ( klogDebug, "XFSGapKartNodeMake ND[$(node)] NM[$(name)] TP[$(project_id)]", "node=%p,name=%s,project_id=%d", ( void * ) Node, Name, ProjectId );
*/

    return RCt;
}   /* XFSGapKartNodeMake () */
Beispiel #4
0
static
rc_t CC
_KartNodeConstructorEx (
            const struct XFSModel * Model,
            const struct XFSModelNode * Template,
            const char * Alias,
            XFSNType Type,
            const struct XFSNode ** Node
)
{
    rc_t RCt;
    struct XFSNode * TheNode;
    const char * NodeName;
    uint32_t ProjectId;
    const char * Var;

    RCt = 0;
    TheNode = NULL;
    NodeName = NULL;
    ProjectId = 0;
    Var = NULL;

    XFS_CSAN ( Node )
    XFS_CAN ( Model )
    XFS_CAN ( Template )
    XFS_CAN ( Node )

    NodeName = Alias == NULL ? XFSModelNodeName ( Template ) : Alias;

    Var = XFSModelNodeProperty ( Template, XFS_MODEL_PROJECTID );
    if ( Var == NULL ) {
        return XFS_RC ( rcInvalid );
    }
    ProjectId = atol ( Var );

    RCt = XFSGapKartNodeMake (
                    & TheNode,
                    NodeName,
                    ProjectId,
                    XFSModelNodeSecurity ( Template )
                    );
    if ( RCt == 0 ) {
        * Node = TheNode;
    }
    else {
        * Node = NULL;

        if ( TheNode != NULL ) {
            XFSNodeDispose ( TheNode );
        }
    }

    return RCt;
}   /* _KartNodeConstructorEx () */
Beispiel #5
0
static
rc_t CC
_AddKartItem (
            struct XFSKartNode * Node,
            const struct XFSGapKart * Kart,
            const char * ItemName
)
{
    rc_t RCt;
    struct XFSNode * ItemNode;
    const struct XFSGapKartItem * KartItem;

    RCt = 0;
    ItemNode = NULL;
    KartItem = NULL;

    XFS_CAN ( Node )
    XFS_CAN ( Kart )
    XFS_CAN ( ItemName )

    KartItem = XFSGapKartGet ( Kart, ItemName );
    if ( KartItem == NULL ) {
        return XFS_RC ( rcInvalid );
    }

    RCt = XFSGapFileNodeMake ( 
                            & ItemNode,
                            ItemName,
                            XFSGapKartItemProjectId ( KartItem ),
                            XFSGapKartItemAccession ( KartItem ),
                            XFSGapKartItemObjectId ( KartItem )
                            );

    if ( RCt == 0 ) {
        RCt = XFSContNodeAddChild (
                                & ( Node -> node . node ),
                                ItemNode
                                );
        if ( GetRCState ( RCt ) == rcExists ) {
            RCt = 0;
        }
        /* We do not dispose node here, but on the caller level */
    }

    if ( RCt != 0 ) {
        if ( ItemNode != NULL ) { 
            XFSNodeDispose ( ItemNode );
            ItemNode = NULL;
        }
    }

    return RCt;
}   /* _AddKartItem () */
Beispiel #6
0
static
rc_t CC
_KartCollectionNodeMakeFromModel (
                    const char * Name,
                    const struct XFSModel * Model,
                    const struct XFSModelNode * Template,
                    struct XFSNode ** Node
)
{
    rc_t RCt;
    struct XFSKartCollectionNode * KartNode;

    RCt = 0;
    KartNode = NULL;

    if ( Node != NULL ) {
        * Node = NULL;
    }

    if ( Name == NULL || Model == NULL || Template == NULL || Node == NULL ) {
        return XFS_RC ( rcNull );
    }

    RCt = _KartCollectionNodeMake (
                                Name,
                                "generic",
                                XFSModelNodeSecurity ( Template ),
                                & KartNode
                                );
    if ( RCt == 0 ) {
        RCt = _LoadKartScanChildren ( Model, Template, KartNode );
        if ( RCt == 0 ) {
            * Node = & ( KartNode -> node . node );
        }
    }

    if ( RCt != 0 ) {
        * Node = NULL;

        if ( KartNode != NULL ) {
            XFSNodeDispose ( & ( KartNode -> node . node ) );
            KartNode = NULL;
        }
    }

/*
printf ( "KartNodeMakeFromModel ND[0x%p] NM[%s] TP[%d]\n", ( void * ) Node, Name, Type );
*/

    return RCt;
}   /* _KartCollectionNodeMakeFromModel () */
Beispiel #7
0
static
rc_t CC
_AddSignatureFile ( struct XFSKartNode * Node )
{
    rc_t RCt;
    struct XFSDoc * Doc;
    struct XFSNode * Sign;

    RCt = 0;
    Doc = NULL;
    Sign = NULL;

    XFS_CAN ( Node )

    RCt = XFSTextDocMake ( & Doc );
    if ( RCt == 0 ) {
        RCt = XFSTextDocAppend ( Doc,
                                "%d\n",
                                Node -> project_id
                                );
        if ( RCt == 0 ) {
            RCt = XFSDocNodeMakeWithFlavor (
                                        & Sign,
                                        Doc,
                                        ".#dbgap-mount-tool#",
                                        XFSPermRODefNodeChar (),
                                        _sFlavorOfFoo
                                        );
            if ( RCt == 0 ) {
                RCt = XFSContNodeAddChild (
                                        & ( Node -> node . node ),
                                        Sign
                                        );
            }
        }

        XFSDocRelease ( Doc );
    }

    if ( RCt != 0 ) {
        if ( Sign != NULL ) { 
            XFSNodeDispose ( Sign );
            Sign = NULL;
        }
    }

    return RCt;
}   /* _AddSignatureFile () */
Beispiel #8
0
LIB_EXPORT
rc_t CC
XFSEncryptedFileNodeMake (
                    const char * Name,
                    const char * Path,
                    const char * Passwd,
                    const char * EncType,
                    struct XFSNode ** Node
)
{
    rc_t RCt;
    const struct XFSEncEntry * Entry;
    struct XFSNode * TheNode;

    RCt = 0;
    Entry = NULL;
    TheNode = NULL;

    XFS_CSAN ( Node )

    XFS_CAN ( Name )
    XFS_CAN ( Path )
    XFS_CAN ( Passwd )
    XFS_CAN ( Node )

    RCt = XFSEncEntryFindOrCreate ( Path, Passwd, EncType, & Entry );
    if ( RCt == 0 ) {
        RCt = XFSEncNodeMake ( & TheNode, Name, Entry );
        if ( RCt == 0 ) {
            * Node = TheNode;
        }
    }

    if ( RCt != 0 ) {
        * Node = NULL;

        if ( TheNode != NULL ) {
            XFSNodeDispose ( TheNode );
        }
        else {
            if ( Entry != NULL ) {
                XFSEncEntryDispose ( Entry );
            }
        }
    }

    return RCt;
}   /* XFSEncryptedFileNodeMake () */
Beispiel #9
0
static
rc_t CC
XFSEncNodeMake (
    struct XFSNode ** Node,
    const char * Name,
    const struct XFSEncEntry * Entry
)
{
    rc_t RCt;
    struct XFSEncNode * xNode;

    RCt = 0;
    xNode = NULL;

    XFS_CSAN ( Node )

    XFS_CAN ( Node )
    XFS_CAN ( Name )
    XFS_CAN ( Entry )

    xNode = calloc ( 1, sizeof ( struct XFSEncNode ) );
    if ( xNode == NULL ) {
        return XFS_RC ( rcNull );
    }

    RCt = XFSNodeInitVT (
                    & ( xNode -> node ),
                    Name,
                    ( const union XFSNode_vt * ) & _sEncNodeVT_v1
                    );

    if ( RCt == 0 ) {
        RCt = XFSEncEntryAddRef ( Entry );
        if ( RCt == 0 ) {
            xNode -> entry = Entry;

            * Node = & ( xNode -> node );
        }
    }

    if ( RCt != 0 ) {
        if ( xNode != NULL ) {
            RCt = XFSNodeDispose ( & ( xNode -> node ) );
        }
    }

    return RCt;
}   /* XFSEncNodeMake () */
Beispiel #10
0
LIB_EXPORT
rc_t CC
XFSKartCollectionNodeMake (
            const char * Name,
            const char * Path,
            const char * Perm,
            struct XFSNode ** Node
)
{
    rc_t RCt;
    struct XFSKartCollectionNode * KartNode;

    RCt = 0;
    KartNode = NULL;

    if ( Node != NULL ) { 
        * Node = NULL;
    }

    if ( Node == NULL || Path == NULL || Name == NULL ) {
        return XFS_RC ( rcNull );
    }

    RCt = _KartCollectionNodeMake ( Name, Path, Perm, & KartNode );
    if ( RCt == 0 ) {
        RCt = _LoadKartScanPath ( KartNode );
        if ( RCt == 0 ) {
            * Node = & ( KartNode -> node . node );
        }
    }

    if ( RCt != 0 ) {
        * Node = NULL;

        if ( KartNode != NULL ) {
            XFSNodeDispose ( & ( KartNode -> node . node ) );
            KartNode = NULL;
        }
    }

/*
printf ( "XFSKartNodeMake ND[0x%p] NM[%s] TP[%d]\n", ( void * ) Node, Name, Type );
*/

    return RCt;
}   /* XFSKartCollectionNodeMake () */
Beispiel #11
0
static
rc_t CC
_BogusNodeMake ( 
            const char * NodeName,
            bool NotFoundType,
            const struct XFSBogusNode ** Node )
{
    rc_t RCt;
    struct XFSBogusNode * TheNode;

    RCt = 0;
    TheNode = NULL;

    if ( NodeName == NULL || Node == NULL ) {
        return XFS_RC ( rcNull );
    }
    * Node = NULL;

    TheNode = calloc ( 1, sizeof ( struct XFSBogusNode ) );
    if ( TheNode == NULL ) {
        RCt = XFS_RC ( rcExhausted );
    }
    else {
        TheNode -> NotFoundType = NotFoundType;

        RCt = XFSNodeInitVT (
                        & ( TheNode -> Node ),
                        NodeName,
                        ( const union XFSNode_vt * ) & _sBogusNodeVT_v1
                        );

        if ( RCt == 0 ) {
            * Node = TheNode;
        }
        else {
            XFSNodeDispose ( ( const struct XFSNode * ) TheNode );
        }
    }
/*
printf ( "_BogusNodeMake ( %s, 0x%p )\n", NodeName, ( void * ) TheNode );
*/

    return RCt;
}   /* _BogusNodeMake () */
Beispiel #12
0
LIB_EXPORT
rc_t CC
XFSDocNodeMakeWithFlavor (
            struct XFSNode ** Node,
            const struct XFSDoc * Doc,
            const char * Name,
            const char * Perm,          /* Could be NULL */
            uint32_t Flavor
)
{
    rc_t RCt;
    struct XFSDocNode * TheNode;

    RCt = 0;
    TheNode = NULL;

    if ( Node != NULL ) {
        * Node = NULL;
    }

    if ( Node == NULL || Name == NULL || Doc == NULL ) {
        return XFS_RC ( rcNull );
    }

    TheNode = calloc ( 1, sizeof ( struct XFSDocNode ) );
    if ( TheNode == NULL ) {
        RCt = XFS_RC ( rcExhausted );
    }
    else {
        RCt = XFSNodeInitVT (
                        & ( TheNode -> node),
                        Name,
                        ( const union XFSNode_vt * ) & _sDocNodeVT_v1
                        );
        if ( RCt == 0 ) {
            if ( Perm != NULL ) {
                RCt = XFS_StrDup ( Perm, & ( TheNode -> perm ) );
            }

            if ( RCt == 0 ) {
                RCt = XFSDocAddRef ( Doc );
                if ( RCt == 0 ) {
                    TheNode -> doc = Doc;

                    TheNode -> flavor = Flavor;

                    * Node = & ( TheNode -> node );
                }
            }
        }
    }

    if ( RCt != 0 ) {
        if ( TheNode != NULL ) {
            XFSNodeDispose ( & ( TheNode -> node ) );
            TheNode = NULL;
        }
    }

/*
pLogMsg ( klogDebug, "XFSDocNodeMake ND[$(node)] NM[$(name)] Doc[$(doc)]", "node=%p,name=%s,doc=%s", ( void * ) TheNode, Name, Doc );
*/

    return RCt;
}   /* XFSDocNodeMakeWithFlavor () */
Beispiel #13
0
LIB_EXPORT
rc_t CC
XFSNodeMake (
            const struct XFSModel * Model,
            const char * NodeName,
            const char * NameAlias,
            const struct XFSNode ** Node
)
{
    rc_t RCt;
    const struct XFSModelNode * ModelNode;
    const struct XFSTeleport * Teleport;
    struct XFSNode * NewNode;
    const char * NewNodeName;

    RCt = 0;
    ModelNode = NULL;
    Teleport = NULL;
    NewNode = NULL;
    NewNodeName = NULL;

    if ( Model == NULL || Node == NULL || NodeName == NULL ) {
        return XFS_RC ( rcNull );
    }

    * Node = NULL;

    ModelNode = XFSModelLookupNode ( Model, NodeName );
    if ( ModelNode == NULL ) {
        return XFS_RC ( rcNotFound );
    }

    if ( XFSModelNodeIsRoot ( ModelNode ) ) {
        NewNodeName = "/";
    }
    else {
            /*  I could use here '?:' operator, but i think that
             *  is more useful, cuz shows names priority:
             *     alias -> label -> name_given
             */
        NewNodeName = NameAlias;
        if ( NewNodeName == NULL ) {

            NewNodeName = XFSModelNodeLabel ( ModelNode );
            if ( NewNodeName == NULL ) {

                NewNodeName = NodeName;
            }
        }
    }

    RCt = XFSTeleportLookup ( 
                    XFSModelNodeType ( ModelNode ),
                    & Teleport
                    );
    if ( RCt == 0 ) {
        if ( Teleport == NULL ) {
            RCt = XFS_RC ( rcInvalid );
        }
        else {
            if ( Teleport -> Constructor == NULL ) {
                RCt = XFS_RC ( rcInvalid );
            }
            else {
                RCt = Teleport -> Constructor (
                                    Model,
                                    ModelNode,
                                    NameAlias,
                                    ( const struct XFSNode ** )& NewNode
                                    );
                if ( RCt == 0 ) {
                    RCt = _NodeSetName ( NewNode, NewNodeName );
                    if ( RCt != 0 ) {
                        XFSNodeDispose ( NewNode );
                    }
                    else {
                        * Node = NewNode;
                    }
                }
            }
        }
    }

/*
pLogMsg ( klogDebug, "XFSNodeMake ( \"$(name)\" ) As [$(alias)] ( $(node) ) [$(rc)]", "name=%s,alias=%s,node=%p,rc=%d", NodeName, ( NameAlias == NULL ? "NULL" : NameAlias ), ( void * ) NewNode, RCt );
*/

    return RCt;
}   /* XFSNodeMake () */
Beispiel #14
0
static
rc_t CC
_ReadMeNodeConstructor (
            const struct XFSModel * Model,
            const struct XFSModelNode * Template,
            const char * Alias,
            const struct XFSNode ** Node
)
{
    rc_t RCt;
    struct XFSNode * TheNode;
    const char * NodeName;
    const char * TextOrSource;
    struct XFSDoc * ReadMe;

    RCt = 0;
    TheNode = NULL;
    NodeName = NULL;
    TextOrSource = NULL;
    ReadMe = NULL;

    if ( Node != NULL ) {
        * Node = NULL;
    }

    if ( Model == NULL || Template == NULL || Node == NULL ) {
        return XFS_RC ( rcNull );
    }

    NodeName = Alias == NULL ? XFSModelNodeName ( Template ) : Alias;

    /*) There could be "text" and "source" parameters, we will leave
      | source for a future development then, and will use it as text
      (*/
    TextOrSource = XFSModelNodeProperty ( Template, XFS_MODEL_TEXT );
    if ( TextOrSource == NULL ) {
        TextOrSource = XFSModelNodeProperty ( Template, XFS_MODEL_SOURCE );
    }

    if ( TextOrSource == NULL ) {
        return XFS_RC ( rcInvalid );
    }

    RCt = XFSTextDocMake ( & ReadMe );
    if ( RCt == 0 ) {

        RCt = XFSTextDocAppend ( ReadMe, "README:\n%s\n", TextOrSource );
        if ( RCt == 0 ) {
            RCt = XFSDocNodeMakeWithFlavor (
                                & TheNode,
                                ReadMe,
                                NodeName,
                                XFSModelNodeSecurity ( Template ),
                                _sFlavorOfReadMe
                                );
            if ( RCt == 0 ) {
                * Node = TheNode;
            }
            else {
                if ( TheNode != NULL ) {
                    XFSNodeDispose ( TheNode );
                }
            }
        }

        XFSDocRelease ( ReadMe );
    }

    return RCt;
}   /* _ReadMeNodeConstructor () */