ACC SHELL

/**
 * Module:      inst_user.ycp
 *
 * Authors:     Klaus Kaempf <kkaempf@suse.de>
 *              Stefan Hundhammer <sh@suse.de>
 *              Jiri Suchomel <jsuchome@suse.cz>
 *
 * Purpose:     Start user management module from within installation workflow
 *
 * $Id: inst_user.ycp 53782 2008-12-01 14:58:07Z jsuchome $
 */
{

    textdomain "users";

    import "Autologin";
    import "Directory";
    import "FileUtils";
    import "GetInstArgs";
    import "Package";
    import "Label";
    import "Ldap";
    import "Progress";
    import "Users";
    import "UsersCache";
    import "UsersSimple";
    import "Wizard";

    include "users/wizards.ycp";

    symbol ret		= `back;
    boolean importing	= false;
    list<map> users     = [];
    map<string,any>user	= $[];

    if (UsersSimple::UserCreationSkipped ())
    {
	y2milestone ("preconfigured user already written...");
	return `auto;
    }
    if (!GetInstArgs::going_back())
    {
	Users::ReadSystemDefaults (false);
	UsersSimple::Read (false);
	Users::SetEncryptionMethod (UsersSimple::EncryptionMethod ());
	users	= (list<map>) UsersSimple::GetUsers ();
	user	= UsersSimple::GetUser ();
	if (size (users) > 1 || user["__imported"]:nil != nil)
	{
	    Users::SetUsersForImport (users);
	    importing	= true;
	    string import_dir	= Directory::vardir + "/imported/userdata/etc";
	    foreach (string file, [ "/passwd", "/shadow", "/group" ], {
		SCR::Execute (.target.remove, import_dir + file);
	    });
	}
    }

    // what to call after inst_auth dialog
    string client	= UsersSimple::AfterAuth();

    // check if the user was configured in the 1st stage
    if (!GetInstArgs::going_back() &&
	client == "users" && user != $[] && !importing)
    {
	y2milestone ("user defined in 1st stage, let's save now...");
	boolean progress_orig = Progress::set (false);
	Users::Read ();

	// now, check if home directory exists and adapt uidnumber to its owner
	string home	= user["home"]:"";
	if (home == "" && user["uid"]:"" != "")
	    home	= Users::GetDefaultHome ("local") + user["uid"]:"";
	if (home != "" && FileUtils::IsDirectory (home) == true)
	{
	    map stat	= (map) SCR::Read (.target.stat, home);
	    integer uid	= stat["uid"]:-1;
	    if (uid != -1)
		user["uidNumber"]	= uid;
	}
	string error	= Users::AddUser (user);
	if (error == "")
	    error	= Users::CheckUser ($[]);
	if (error == "" && Users::CommitUser ())
	{
	    if (UsersSimple::AutologinUsed ())
	    {
		Autologin::user	= UsersSimple::GetAutologinUser ();
		Autologin::used = true;
		Autologin::modified = true;
	    }
	    string root_alias	= UsersSimple::GetRootAlias ();
	    if (root_alias != "")
	    {
		Users::AddRootAlias (root_alias);
	    }
	    error = Users::Write ();
	    UsersSimple::SetUser ($[]);
	}
	if (error != "")
	    y2error ("error while creating user: %1", error);
	Progress::set (progress_orig);
	UsersSimple::RemoveUserData ();
	UsersSimple::SkipUserCreation (true);
	return `next;
    }
    if (Mode::normal ()) Wizard::CreateDialog (); // for testing only

    if (!GetInstArgs::going_back() && client == "users" &&
	UsersSimple::UsersWritten ())
    {
	y2milestone ("users already written, going next");
	return `next;
    }
    // dialog caption
    string caption = _("User Authentication Method");

    if (!importing)
	Wizard::SetContents (caption, `Empty (),
	// help text (shown in the 'busy' situation)
	_("Initialization of module for configuration of authentication..."),
	GetInstArgs::enable_back(), GetInstArgs::enable_next());

    if (client != "users")
    {
	// going back from next step, while kerberos was already configured
	if (UsersSimple::KerberosConfiguration () && GetInstArgs::going_back ()
	    &&
	    Package::Installed ("yast2-kerberos-client"))
	{
	    ret = (symbol) WFM::CallFunction ("kerberos-client", WFM::Args ());
	    if (ret == `next)
		return ret;
	}

        string package = sformat("yast2-%1-client", client);
	// name of client to call
        map call_client = $[
	    "samba": "samba-client",
	    "edir_ldap" : "linux-user-mgmt",
	];
	if (client == "edir_ldap")
	    package = "yast2-linux-user-mgmt";
	if (!Package::InstallAllMsg ([package],
            // popup label (%1 is package to install)
            sformat (_("Package %1 is not installed.
Install it now?
"), package)))
        {
	    return `back;
	}

	// when we go `back from kerberos, call previous client again
	boolean again	= true;
	while (again)
	{
	    again	= false;
            ret = (symbol) WFM::CallFunction (call_client [client]:client,
		WFM::Args ());

	    // after nis/ldap/edit client was called, maybe call also kerberos
	    if (ret == `next && UsersSimple::KerberosConfiguration () &&
		Package::InstallAllMsg (["yast2-kerberos-client"],
		// popup label (%1 is package to install)
		sformat (_("Package %1 is not installed.
Install it now?
"), "yast2-kerberos-client")))
	    {
		ret = (symbol) WFM::CallFunction ("kerberos-client",
		    WFM::Args ());
		if (ret == `back)
		    again	= true;
	    }
	}

	if (ret == `next && client == "ldap" && Ldap::initial_defaults_used)
	{
	    // continue with users...
	    UsersSimple::SetAfterAuth ("users");
	    y2milestone("calling users module to enable creating LDAP user...");
	}
	else
	{
	    // ldap not used, or the client configuration is different than
	    // proposal from ldap server
	    return (symbol) ret;
	}
    }
    list import_u	= Users::GetUsersForImport ();
    if (size (import_u) > 0)
    {
	if (GetInstArgs::going_back())
	{
	    Users::SetUsersForImport ([]);
	    return `back;
	}
	ReadDialog (false); // clear the cache from imported data
	Users::ResetCurrentUser ();
	y2milestone ("There are some users to import");
	foreach (map<string,any> user, (list<map<string,any> >) import_u, {
	    user["encrypted"]	= true;
	    // check if default group exists
	    if (haskey (user, "gidNumber"))
	    {
		map g	= Users::GetGroup (GetInt (user["gidNumber"]:nil, -1), "");
		if (g == $[])
		{
		    g	= Users::GetGroupByName (user["groupname"]:"", "");
		    if (g != $[])
			user["gidNumber"]	= g["gidNumber"]:-1;
		    else
			user	= remove (user, "gidNumber");
		}
	    }
	    string error = Users::AddUser (user);
	    if (error != "")
	    {
		y2error ("error while adding user: %1", error);
	    }
	    error = Users::CheckUser ($[]);
	    if (error != "")
	    {
		y2error ("error while adding user: %1", error);
	    }
	    Users::CommitUser ();
	});
	WriteDialog (false);
	ret = `auto;
    }
    else
    {
	// else run the users module
	y2milestone ("Starting user management module with parameters %1",
	    GetInstArgs::argmap());

	UsersCache::SetCurrentSummary ("users");
	Users::SetStartDialog ("user_inst_start");
	ret = UsersSequence ("user_inst_start");

	y2milestone ("User management module returned %1", ret );
    }

    if ( ret == nil )
    {
        y2warning( "UsersSequence returns null!" );
        ret = `auto;
    }
    if (ret == `next)
    {
	UsersSimple::RemoveUserData ();
    }
    if (Mode::normal ()) Wizard::CloseDialog ();
    return (symbol) ret;
}