groups.c

PGP—Pretty Good Privacy

    err = PGPGetKeyNumber( key, kPGPKeyPropAlgID, &algorithm);
    item->u.key.algorithm = (PGPPublicKeyAlgorithm)algorithm;

    err = PGPGetKeyIDFromKey(key, &keyID);
    pgpAssertNoErr(err);

    item->u.key.keyID = keyID;

    return kPGPError_NoErr;
}


PGPError addKeySetToGroup (struct pgpmainBones *mainbPtr, PGPGroupID
        groupID, char * groupName, char * useridstr, PGPFileSpecRef
        ringfilespec)

{
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPGroupSetRef groupSet = mainbPtr->workingGroupSet;
    PGPUInt32 matchFlags = 0;
    PGPKeySetRef resultSet;
    PGPKeyListRef resultList;
    PGPKeyRef key;
    PGPKeyIterRef iter;
    PGPKeyID keyID;
    PGPError err;
    PGPGroupItem item;

    err = pgpGetMatchingKeySet(mainbPtr, useridstr, matchFlags, &resultSet);
    pgpAssertNoErr(err);

    err = PGPOrderKeySet( resultSet, kPGPAnyOrdering, &resultList );
    pgpAssertNoErr(err);

    err = PGPNewKeyIter( resultList, &iter );
    pgpAssertNoErr(err);
    err = PGPKeyIterRewind( iter );
    pgpAssertNoErr(err);
    err = PGPKeyIterNext( iter, &key);

    if( IsPGPError(err)) {
        fprintf(filebPtr->pgpout, LANG("No matching keys found.\n"));
        goto done;
    }

    while( key != NULL ) {

        err = createNewKeyItem( key, &item );
        pgpAssertNoErr(err);

        err = getKeyIDFromItem(&item, &keyID);
        pgpAssertNoErr(err);

        err = showKeyGroupFormat(filebPtr, resultSet, groupSet,
                keyID, 0, FALSE);

        err = PGPAddItemToGroup(groupSet, &item, groupID);

        if ( IsPGPError (err)) {

            fprintf(filebPtr->pgpout,
                    LANG(" already in group \'%s\'.\n"), groupName);
        }
        else {

            fprintf(filebPtr->pgpout,
                    LANG(" added to group \'%s\'.\n"), groupName);
        }

        err = PGPKeyIterNext( iter, &key);
    }

done:
    if(iter)
        PGPFreeKeyIter( iter );
    if(resultList)
        PGPFreeKeyList( resultList );
    if(resultSet)
        PGPFreeKeySet( resultSet );

    return kPGPError_NoErr;
}


/*
   Create a new group, pgp -ga groupname
   add [a] member/s to a group, pgp -ga groupname [userids]
   or add all members of group 2 to group 1.
   pgp -ga groupname1 groupname2
 */
int addToGroup(struct pgpmainBones *mainbPtr, char *groupName, char
        **mcguffins, PGPFileSpecRef ringfilespec)
{
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPGroupName groupDescription;
    PGPUInt32 i = 0;
    PGPError err;
    PGPGroupID groupID;

    err = pgpGetGroupByName( mainbPtr->workingGroupSet, groupName,
            &groupID );

    if ( IsPGPError(err) ) /* New Group */
    {
        if( filebPtr->pgpout ) {

            fputs( LANG("\nGroup Description: "), filebPtr->pgpout);
            fflush( filebPtr->pgpout );
        }

        pgpTtyGetString( groupDescription,
                kPGPMaxGroupNameLength, filebPtr->pgpout );
        err = PGPNewGroup( mainbPtr->workingGroupSet,
                groupName, groupDescription, &groupID);
        pgpAssertNoErr( err);

        fprintf(filebPtr->pgpout,
                LANG("Group \'%s\' added.\n"), groupName);
    } else {
        if (mcguffins[0] == NULL)
        {
            fprintf(filebPtr->pgpout,
                    LANG("Group \'%s\' already exists.\n"), groupName );

            return kPGPError_NoErr;

        }
    }

    while (mcguffins[i] != NULL) {
        /* Add groupname or userid. If ambiguous, does both. */
        err =addKeySetToGroup (mainbPtr, groupID, groupName, mcguffins[i],
                ringfilespec);
        pgpAssertNoErr(err);
        i++;
    }

    return kPGPError_NoErr;
}

/*
   Functions to remove a group, or delete keys from a group.
   For pgp -gr

   XXX NOTE: THESE FUNCTIONS REQUIRE PATCH IN
    /libs/pgpcdk/priv/utilities/pgpGroups.c
*/

/* Remove keys in keySetToRemove. */
PGPError removeKeySetFromGroup(struct pgpfileBones *filebPtr,
        PGPGroupSetRef groupSet, PGPGroupID groupID, char *groupName,
        PGPKeySetRef keySetToRemove, PGPKeySetRef keySet )

{
    PGPKeyRef key;
    PGPKeyID keyID;
    PGPError err;
    PGPGroupItem item;
    PGPUInt32 countKeys, countItems, i;
    PGPBoolean done = FALSE;

    err = PGPCountGroupItems(groupSet, groupID, FALSE,
            &countKeys, &countItems);
    pgpAssertNoErr( err );

    if (countItems == 0) {

        fprintf(filebPtr->pgpout,
                LANG("Empty group: \'%s\'.\n"), groupName);
        return kPGPError_NoErr;
    }

    for (i=0; i<countItems; i++) {
        err = PGPGetIndGroupItem( groupSet, groupID, i, &item);
        pgpAssertNoErr(err);

        err = getKeyIDFromItem(&item, &keyID);
        pgpAssertNoErr(err);

        err = PGPGetKeyByKeyID( keySet, &keyID,
                kPGPPublicKeyAlgorithm_Invalid, &key);
        pgpAssertNoErr(err);

        if ( PGPKeySetIsMember(key, keySetToRemove) ) {
            err = PGPDeleteIndItemFromGroup(groupSet, groupID, i);
            pgpAssertNoErr(err);

            /* Deletion auto-decrements indices. */
            i = i - 1;
            countItems = countItems - 1;

            if (IsntPGPError(err)) done = TRUE;

            showKeyGroupFormat(filebPtr, keySet,
                    groupSet, keyID, 0, FALSE);
            pgpAssertNoErr(err);

            fprintf(filebPtr->pgpout,
                    LANG(" removed from group \'%s\'.\n"), groupName);
        }
    }

    if (!done) fprintf(filebPtr->pgpout,
            LANG("Key(s) not found in group \'%s\'.\n"), groupName);

    return kPGPError_NoErr;
}


PGPError removeKeySetFromGroupSet(struct pgpmainBones *mainbPtr,
        PGPGroupSetRef groupSet, PGPGroupID targetGroupID, char *groupName,
        PGPKeySetRef keySetToRemove, PGPFileSpecRef ringfilespec)

{
    PGPContextRef context = mainbPtr->pgpContext;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPUInt32 i, count;
    PGPError err;
    PGPKeySetRef keySet;
    PGPGroupID groupID;


    /* For removeKeySetFromGroup, open the groups' keyset. */

    err = PGPOpenKeyRing( context, kPGPKeyRingOpenFlags_Mutable,
            ringfilespec, &keySet);
    pgpAssertNoErr(err);

    err = PGPCountGroupsInSet( groupSet, &count);
    pgpAssertNoErr( err );

    if (count == 0)
        fprintf(filebPtr->pgpout, LANG("No groups found.\n"));

    for (i = 0; i < count; i++) {

        err = PGPGetIndGroupID( groupSet, i, &groupID);
        pgpAssertNoErr( err );

        if (targetGroupID == groupID) {

            err = removeKeySetFromGroup(filebPtr, groupSet,
                    groupID, groupName, keySetToRemove, keySet);
            pgpAssertNoErr( err );
        }
    }

    if (keySet) {
        err = PGPFreeKeySet( keySet );
        pgpAssertNoErr(err);
    }
    return kPGPError_NoErr;
}


/*
   Remove a key or keys from a group, pgp -gr groupname [userids]
   remove the contents of group 2 from group 1:
   pgp -gr groupname1 groupname2
   or remove a group. pgp -gr groupname
*/
int removeFromGroup(struct pgpmainBones *mainbPtr, char *groupName,
        char **mcguffins, PGPFileSpecRef ringfilespec)
{
    PGPEnv *env = mainbPtr->envbPtr->m_env;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPGroupSetRef groupSet = mainbPtr->workingGroupSet;
    PGPUInt32 i = 0, countKeys, countItems;
    PGPInt32 pri;
    PGPKeySetRef keySetToRemove;
    PGPError err;
    PGPGroupID groupID;
    PGPBoolean boo = TRUE;

    err = pgpGetGroupByName( mainbPtr->workingGroupSet, groupName,
            &groupID );

    if ( IsPGPError(err) ) {
        fprintf(filebPtr->pgpout,
                LANG("Group \'%s\' not found.\n"), groupName );
    } else {
        if (mcguffins[0] == NULL) {
            err = PGPCountGroupItems(groupSet, groupID,
                    FALSE, &countKeys, &countItems);
            pgpAssertNoErr( err );

            if (countItems != 0) {

                if( filebPtr->pgpout ) {

                    fprintf(filebPtr->pgpout, LANG(
                        "Group '%s' not empty. Remove it anyway? (y/N)\n"),
                        groupName);
                    fflush( filebPtr->pgpout );
                }
                boo =  getyesno(filebPtr,'n', pgpenvGetInt( env,
                        PGPENV_BATCHMODE, &pri, &err ));

            }

            if (boo) {
                err = PGPDeleteGroup(groupSet, groupID);
                pgpAssertNoErr(err);

                if (!IsPGPError(err))
                    fprintf(filebPtr->pgpout,
                            LANG("Group '%s' removed.\n"), groupName);
            }
        }
        while (mcguffins[i] != NULL) {
            err = pgpGetMatchingKeySet(mainbPtr, mcguffins[i],
                    0, &keySetToRemove);
            pgpAssertNoErr(err);

            /* This removes either keys or groups,
               due to pgpGetMatchingKeySet's strategy. */

            err = removeKeySetFromGroupSet(mainbPtr, groupSet,
                    groupID, groupName, keySetToRemove, ringfilespec );
            pgpAssertNoErr(err);

            i++;
        }
    }
    return kPGPError_NoErr;
}