OpenNebula

    bool driver_managed_groups = false;

    bool update_groups;

    const VectorAttribute* auth_conf;

    int      new_gid = -1;

    set<int> new_group_ids;

    set<int> groups_remove;

    set<int> groups_add;

    set<int>::iterator it;

    int     rc;

    Group* group;

    GroupPool* gpool = nd.get_gpool();

    if (nd.get_auth_conf_attribute(auth_driver, auth_conf) == 0)

    {

        auth_conf->vector_value("DRIVER_MANAGED_GROUPS", driver_managed_groups);

    }

        if (driver_managed_groups)

        {

            //------------------------------------------------------------------

            // Parse driver response

            //------------------------------------------------------------------

            string   driver_name;

            string   mad_name;

            string   mad_pass;

            string   error_str;

            rc = parse_auth_msg(ar, new_gid, new_group_ids,

                    driver_name, mad_name, mad_pass, error_str);

            if (rc != 0)

            {

                oss << "An error ocurred parsing the driver message. "

                    << error_str;

                NebulaLog::log("AuM",Log::WARNING,oss);

                oss.str("");

            }

        }

    update_groups = (driver_managed_groups &&

                     (new_gid != -1) && (new_group_ids != group_ids));

    if (update_groups && (new_group_ids.count(group_id) == 0))

    {

        // Old primary group disappears from the list of new groups

        group = gpool->get(new_gid, true);

        if (group != 0)

        {

            group_id = new_gid;

            gname    = group->get_name();

            group->unlock();

        }

    }

        if (update_groups)

        {

            // Previous groups that were not returned this time

            std::set_difference(group_ids.begin(), group_ids.end(),

                    new_group_ids.begin(), new_group_ids.end(),

                    std::inserter(groups_remove, groups_remove.end()));

            // New groups

            std::set_difference(new_group_ids.begin(), new_group_ids.end(),

                    group_ids.begin(), group_ids.end(),

                    std::inserter(groups_add, groups_add.end()));

            // Set main group

            user->set_group(group_id, gname);

            // Add secondary group ids in the user object

            for(it = groups_add.begin(); it != groups_add.end(); it++)

            {

                if (gpool->get(*it, false) != 0)

                {

                    user->add_group(*it);

                }

                else

                {

                    oss << "Driver " << auth_driver

                        << " returned the non-existing group ID " << *it

                        << " for user " << uname;

                    NebulaLog::log("AuM",Log::WARNING,oss);

                    oss.str("");

                }

            }

            // Remove secondary group ids from the user object

            for(it = groups_remove.begin(); it != groups_remove.end(); it++)

            {

                user->del_group(*it);

            }

            // Update the list of groups to return

            group_ids = user->get_groups();

            update(user);

        }

    // Add/remove user ID from the group objects

    for(it = groups_add.begin(); it != groups_add.end(); it++)

    {

        group = gpool->get(*it, true);

        if (group == 0)

        {

            continue;

        }

        group->add_user(user_id);

        gpool->update(group);

        group->unlock();

    }

    for(it = groups_remove.begin(); it != groups_remove.end(); it++)

    {

        group = gpool->get(*it, true);

        if (group == 0)

        {

            continue;

        }

        group->del_user(user_id);

        gpool->update(group);

        group->unlock();

    }

int UserPool::parse_auth_msg(

    AuthRequest &ar,

    int         &gid,

    set<int>    &group_ids,

    string      &driver_name,

    string      &mad_name,

    string      &mad_pass,

    string      &error_str)

{

    istringstream is;

    //--------------------------------------------------------------------------

    // Parse driver response format is:

    // <driver> <username> <passwd> [gid...]

    //--------------------------------------------------------------------------

    is.str(ar.message);

    if ( is.good() )

    {

        is >> driver_name >> ws;

    }

    if ( !is.fail() )

    {

        is >> mad_name >> ws;

    }

    if ( !is.fail() )

    {

        is >> mad_pass >> ws;

    }

    while ( is.good() )

    {

        int tmp_gid;

        is >> tmp_gid >> ws;

        if ( is.fail() )

        {

            error_str = "One or more group IDs are malformed";

            return -1;

        }

        if ( Nebula::instance().get_gpool()->get(tmp_gid, false) == 0 )

        {

            error_str = "One or more group IDs do not exist";

            return -1;

        }

        if ( gid == -1 ) //Keep the first id for primary group

        {

            gid = tmp_gid;

        }

        group_ids.insert(tmp_gid);

    }

    return 0;

}

/* -------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

    int     rc;

    // Parse driver response

    rc = parse_auth_msg(ar, gid, group_ids,

            driver_name, mad_name, mad_pass, error_str);

    if (rc != 0)

        goto auth_failure_user;

    allocate(&user_id,

             group_id,

             mad_name,

             gname,

             mad_pass,

             driver_name,

             true,

             error_str);