/* 
   netcfg.c - Configure a network via DHCP or manual configuration 
   for debian-installer

   Copyright (C) 2000-2002  David Kimdon <dwhedon@debian.org>
                            and others (see debian/copyright)
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <cdebconf/debconfclient.h>
#include <debian-installer.h>
#include <iwlib.h>
#include "netcfg.h"

static method_t netcfg_method = DHCP;

response_t netcfg_get_method(struct debconfclient *client)
{
    int iret, ret;

    iret = debconf_input(client, "medium", "netcfg/use_dhcp");
    ret = debconf_go(client);

    if (ret == 30)
      return GO_BACK;
    
    debconf_get(client, "netcfg/use_dhcp");

    if (strcmp(client->value, "true") == 0)
      netcfg_method = DHCP;
    else 
      netcfg_method = STATIC;

    if (iret == 30)
      return NOT_ASKED;

    return 0;
}

int main(int argc, char *argv[])
{
    int num_interfaces = 0;
    enum { BACKUP, GET_INTERFACE, GET_HOSTNAME_ONLY, GET_METHOD, GET_DHCP, GET_STATIC, WCONFIG, WCONFIG_ESSID, WCONFIG_WEP, QUIT } state = GET_INTERFACE;
    static struct debconfclient *client;
    static int requested_wireless_tools = 0;
	char **ifaces;
	char *defiface = NULL, *defwireless = NULL;
    response_t res;

    /* initialize libd-i */
    di_system_init("netcfg");

    parse_args (argc, argv);
    reap_old_files ();
    open_sockets();

    /* initialize debconf */
    client = debconfclient_new();
    debconf_capb(client, "backup");

    /* always always always default back to DHCP, unless you've specified
     * disable_dhcp on the command line. */
    debconf_get(client, "netcfg/disable_dhcp");
    
    if (!strcmp(client->value, "true"))
      debconf_set(client, "netcfg/use_dhcp", "false");
    else
      debconf_set(client, "netcfg/use_dhcp", "true");

    for (;;)
    {
	switch(state)
	{
	case BACKUP:
	    return 10;
	case GET_INTERFACE:
		/* Choose a default from ethtool-lite */
		if (get_all_ifs(1, &ifaces) > 1)
		{
			while (*ifaces)
			{
				interface_up(*ifaces);
				
				usleep(250);
				
				if (ethtool_lite (*ifaces) == 1) /* CONNECTED */
				{
					defiface = strdup(*ifaces);
					interface_down(*ifaces);
					break;
				}
				else
				{
					struct wireless_config wc;

					if (iw_get_basic_config(wfd, *ifaces, &wc) == 0)
					{
						wc.essid[0] = '\0';
						wc.essid_on = 0;

						iw_set_basic_config(wfd, *ifaces, &wc);
						
						sleep(1);

						iw_get_basic_config(wfd, *ifaces, &wc);

						if (!empty_str(wc.essid))
						{
							di_info("%s is associated with %s. Selecting as default", *ifaces, wc.essid);
							defiface = strdup(*ifaces);
							interface_down(*ifaces);
							break;
						}
						else
						{
							di_info("%s is not associated. Relegating to defwireless", *ifaces);
							if (defwireless != NULL)
								free (defwireless);
							defwireless = strdup(*ifaces);
						}
					}
					else
						di_info("%s is not a wireless interface. Continuing.", *ifaces);

					interface_down(*ifaces);
				}

				interface_down(*ifaces);

				ifaces++;
			}
		}
	    
		if (!defiface && defwireless)
			defiface = defwireless;

		if(netcfg_get_interface(client, &interface, &num_interfaces, defiface))
	      state = BACKUP;
	    else if (! interface || ! num_interfaces)
	      state = GET_HOSTNAME_ONLY;
	    else
	    {
	      if (is_wireless_iface (interface))
		state = WCONFIG;
	      else
		state = GET_METHOD;
	    }
	    break;
	case GET_HOSTNAME_ONLY:
	    if(netcfg_get_hostname(client, "netcfg/get_hostname", &hostname, 0))
	      state = BACKUP;
	    else
	    {
	      struct in_addr null_ipaddress;
	      null_ipaddress.s_addr = 0;
	      netcfg_write_common(null_ipaddress, hostname, NULL);
	      state = QUIT;
	    }
	    break;
	case GET_METHOD:
	    if ((res = netcfg_get_method(client)) == GO_BACK)
		state = (num_interfaces == 1) ? BACKUP : GET_INTERFACE;
	    else
	    {
              if (netcfg_method == DHCP) 
                state = GET_DHCP;
              else
                state = GET_STATIC;
	    }
	    break;

	case GET_DHCP:
            switch (netcfg_activate_dhcp(client))
            {
              case 0:
                state = QUIT;
                break;
              case 10:
                /*
                 * It doesn't make sense to go back to GET_METHOD because
                 * the user has already been asked whether he wants to
                 * try an alternate method.
                 */
                state = (num_interfaces == 1) ? BACKUP : GET_INTERFACE;
                break;
              case 15:
                state = GET_STATIC;
                break;
              default:
                return 1;
            }
	    break;

	case GET_STATIC:
        {
            int ret;
	    /* Misnomer - this should actually take care of activation */
	    if ((ret = netcfg_get_static(client)) == 10)
		state = GET_INTERFACE;
            else if (ret)
                state = GET_METHOD;
	    else
	        state = QUIT;
	    break;
        }
        
        case WCONFIG:
	    if (requested_wireless_tools == 0)
	    {
	      di_exec_shell_log("apt-install wireless-tools");
	      requested_wireless_tools = 1;
	    }
	    state = WCONFIG_ESSID;
	    break;

	case WCONFIG_ESSID:
	    if (netcfg_wireless_set_essid (client, interface, NULL) == GO_BACK)
	      state = BACKUP;
	    else
	      state = WCONFIG_WEP;
	    break;
            
	case WCONFIG_WEP:
	    if (netcfg_wireless_set_wep (client, interface) == GO_BACK)
	      state = WCONFIG_ESSID;
	    else
	      state = GET_METHOD;
	    break;

	case QUIT:
	    return 0;
	}
    }

}