ppp_modem.cxx

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

       ppp_modem_setup_delete_button->show();
     */
}

void
PPP_Add_Config::show()
{
    get_parent_window()->show();
}

void
PPP_Add_Config::hide()
{
    get_parent_window()->hide();
}

///////////////////////////////////////////////////////////
//
//      function:               PPP_Modem_Setup::show()
//      description:    show the object
//      parameters:             none
//      returns:                        none
//
///////////////////////////////////////////////////////////
void
PPP_Modem_Setup::show()
{
    get_parent_win()->show();
}

///////////////////////////////////////////////////////////
//
//      function:               PPP_Modem_Setup::PPP_Modem_Setup
//      description:    PPP_Modem_Setup class instatiation function
//      parameters:             Fl_Tabs *ppp_setup_tabs - pointer to parent tabs
//                                              PPP_Modem *this_modem - pointer to parent object
//      returns:                        none
//
///////////////////////////////////////////////////////////
PPP_Modem_Setup::PPP_Modem_Setup(PPP_Modem * this_modem)
{
    account_modem = this_modem;

    modem_setup_win = new NxPimWindow("Setup", setupMenuItems, MENU);
    NetConfig::I()->add_window((Fl_Window *) modem_setup_win->GetWindowPtr());

    ppp_setup_group = new Fl_Group(W_X, W_Y, W_W, W_H);

    ppp_modem_setup_browser = new NxHoldBrowser((240 - (MENU_W) + 20) / 2,
						2 * MENU_Y + MENU_H + 5,
						MENU_W - 20,
						BUTTON_Y - 5 -
						(BUTTON_HEIGHT + MENU_Y +
						 MENU_H), "Configurations");
    ppp_modem_setup_browser->align(FL_ALIGN_TOP);

    ppp_modem_setup_add_button = new NxButton(3, BUTTON_Y, BUTTON_WIDTH - 4,
					      BUTTON_HEIGHT, "Add");
    ppp_modem_setup_edit_button = new NxButton(62, BUTTON_Y, BUTTON_WIDTH - 4,
					       BUTTON_HEIGHT, "Edit");
    ppp_modem_setup_delete_button =
	new NxButton(121, BUTTON_Y, BUTTON_WIDTH - 4, BUTTON_HEIGHT,
		     "Delete");

    ppp_modem_setup_add_button->callback(ppp_add_config_cb, this);
    ppp_modem_setup_edit_button->callback(ppp_add_config_cb, this);
    ppp_modem_setup_delete_button->callback(ppp_delete_config_cb, this);

    {
	NxButton *o =
	    new NxButton(181, BUTTON_Y, BUTTON_WIDTH - 4, BUTTON_HEIGHT,
			 "Done");
	o->callback(NetConfig::show_modem);
    }

    ppp_setup_group->end();

    modem_setup_win->add((Fl_Widget *) ppp_setup_group);

    fill_config_browser();
}

/********************ppp_modem**************************************/

///////////////////////////////////////////////////////////
//
//      function:               PPP_Modem::set_ppp_options()
//      description:    set get options for config and account
//      parameters:             none
//      returns:                        none
//              
///////////////////////////////////////////////////////////             
void
PPP_Modem::set_ppp_options()
{
    char account_value[25];
    char config_value[25];
    char phone[20] = "";
    char password[25] = "";
    char username[25] = "";
    char device[128] = "";
    char speed[10] = "";
    char dest_ip[16] = "";
    char source_ip[16] = "";
    //char broadcast_ip[16] = "";
    //char gateway_ip[16] = "";

    if (ppp_config_choice->text()) {
	strcpy(config_value, ppp_config_choice->text());
    } else {
	strcpy(config_value, "");
    }
    if (ppp_account_choice->text()) {
	strcpy(account_value, ppp_account_choice->text());
    } else {
	strcpy(account_value, "");
    }
    IniGetString(account_value, "number", NULL, phone, sizeof(phone) - 1,
		 ACCOUNT_FILE);
    IniGetString(account_value, "password", NULL, password,
		 sizeof(password) - 1, ACCOUNT_FILE);
    IniGetString(account_value, "username", NULL, username,
		 sizeof(username) - 1, ACCOUNT_FILE);
    IniGetString(config_value, "device", NULL, device, sizeof(device) - 1,
		 CONFIG_FILE);
    IniGetString(config_value, "speed", NULL, speed, sizeof(speed) - 1,
		 CONFIG_FILE);
    IniGetString(config_value, "dest", NULL, dest_ip, sizeof(dest_ip) - 1,
		 CONFIG_FILE);
    IniGetString(config_value, "source", NULL, source_ip,
		 sizeof(source_ip) - 1, CONFIG_FILE);

    unsigned long val = strtol(speed, NULL, 10);
    ppp_options.speed = val;
    strcpy(ppp_options.device, device);
    strcpy(ppp_options.telephone, phone);
    strcpy(ppp_options.account, username);
    strcpy(ppp_options.password, password);
    ppp_options.local_ipaddr = inet_network(source_ip);
    ppp_options.remote_ipaddr = inet_network(dest_ip);
}

///////////////////////////////////////////////////////////
//
//      function:               PPP_Modem::get_script()
//      description:    get script value from file
//      parameters:             char *script - pointer to script value
//      returns:                        none
//
///////////////////////////////////////////////////////////
void
PPP_Modem::get_script(char *script)
{
    char file[255] = "";
    FILE *fp;
    char buf[4096] = "";
    off_t pos = 0;

    sprintf(file, "%s%s", SCRIPT_PREFIX, ppp_config_choice->text());
    if ((fp = fopen(file, "r")) == NULL) {
	return;
    }
    while (NULL != fgets(buf, sizeof(buf) - 1, fp)) {
	pos += strlen(buf);
	if (MAX_SCRIPT_SIZE < pos) {
	    off_t diff = pos - MAX_SCRIPT_SIZE;
	    strncat(script, buf, strlen(buf) - diff - 1);
	    break;
	} else {
	    strncat(script, buf, strlen(buf));
	}
    }
    fclose(fp);
}

///////////////////////////////////////////////////////////
//
//      function:               PPP_Modem::set_pppd_command()
//      descriptons:    fille out the array of command strings from the script
//      parameters;             char *script - script string
//                                              int *count - count of how many string in array
//      returns:                        char ** - pointer to array of string
//
///////////////////////////////////////////////////////////
char **
PPP_Modem::set_pppd_command(char *script, int *count)
{
    int byte_count = 0;
    unsigned int idx;
    int c;
    int new_line = 0;
    char **pppd_command;
    char *buf;
    char *tmp_ptr;

    if (0 == strcmp("", script)) {
	return (NULL);
    }
    buf = (char *) calloc(MAX_SCRIPT_SIZE + 1, sizeof(char));
    if (NULL == buf) {
	perror("PPP_Modem (CALLOC)");
	return (NULL);
    }
    tmp_ptr = buf;

    strcpy(buf, script);
    for (idx = 0; idx < strlen(script); idx++) {
	c = script[idx];
	if (c == '\n' || c == '\0') {
	    new_line++;
	}
    }
    *count = new_line;
    if ((pppd_command =
	 (char **) calloc(new_line + 1, sizeof(char *))) == NULL) {
	perror("PPP_Modem (CALLOC)");
	return (NULL);
    }
    new_line = 0;
    for (idx = 0; idx < strlen(script); idx++) {
	byte_count++;
	c = script[idx];
	if (c == '\n' || c == '\0') {
	    pppd_command[new_line] =
		(char *) calloc(byte_count + 1, sizeof(char));
	    if (pppd_command[new_line] == NULL) {
		perror("PPP_Modem (CALLOC)");
		if (NULL != buf) {
		    buf = tmp_ptr;
		    free(buf);
		}
		free(pppd_command);
		return (NULL);
	    }
	    strncpy(pppd_command[new_line], buf, byte_count - 1);
	    buf += byte_count;
	    byte_count = 0;
	    new_line++;
	}
    }
    if (NULL != buf) {
	buf = tmp_ptr;
	free(buf);
    }
    return pppd_command;
}

///////////////////////////////////////////////////////////
//
//      function:               PPP_Modem::ppp_connect_button_cb
//      descriptioin:   callback function for connect button
//      parameters:             Fl_widget *widget - pointer to calling widget
//                                              void *parent - pointer to parent object
// returns:                     none
//
///////////////////////////////////////////////////////////
void
PPP_Modem::ppp_connect_button_cb(Fl_Widget * widget, void *parent)
{
    PPP_Modem *modem = (PPP_Modem *) parent;
    pix_comm_ppp_options_t ppp_options;
    char dhcp[5] = "";
    char config_value[25];
    int dhcp_i;
    char **pppd_command;
    char script[MAX_SCRIPT_SIZE] = "";
    int err;
    int count;

    modem->set_ppp_options();
    modem->set_status(pix_comm_if_active("ppp0"));

    if (PIX_COMM_ACTIVE == modem->get_status()) {
	pix_comm_ppp_disconnect("ppp0");
	sleep(7);
    } else {
	if (modem->ppp_config_choice->text()) {
	    strcpy(config_value, modem->ppp_config_choice->text());
	} else {
	    strcpy(config_value, "");
	}
	IniGetString(config_value, "dhcp", NULL, dhcp, sizeof(dhcp) - 1,
		     CONFIG_FILE);
	if (!strcasecmp("on", dhcp)) {
	    dhcp_i = 1;
	} else {
	    dhcp_i = 0;
	}
	ppp_options = modem->get_ppp_options();
	modem->get_script(script);
	if (0 != strcmp("", script)) {
	    pppd_command = modem->set_pppd_command(script, &count);
	    modem->set_status_box("    Attempting to start interface");
	    err =
		pix_comm_ppp_connect(PIX_COMM_PPP_MODEM, &ppp_options,
				     pppd_command, count, dhcp_i,
				     config_value);
	    if (NULL != pppd_command) {
		free(pppd_command);
	    }
	} else {
	    modem->set_status_box("    Attempting to start interface");
	    err = pix_comm_ppp_connect(PIX_COMM_PPP_MODEM, &ppp_options,
				       NULL, 0, dhcp_i, config_value);
	}
	if (err) {
	    modem->set_status_box("       Error starting  interface ppp0");
	    return;
	}
    }
    modem->set_status_box();
}

///////////////////////////////////////////////////////////
//
//      function:               PPP_Modem::ppp_device_setup_cb()
//      description:    callback function for setup of device/configuration
//      parameters:             Fl_Widget *widget - pointer to calling widget
//                                              void *parent - pointer to parent object
//      returns:                        none
//
///////////////////////////////////////////////////////////     
void
PPP_Modem::ppp_device_setup_cb(Fl_Widget * widget, void *parent)
{
    ((PPP_Modem *) parent)->ppp_device_setup->show();
}

///////////////////////////////////////////////////////////
//
//      fucntion:               PPP_Modem::ppp_account_setup_cb
//      description:    callback function for edit acounts
//      parameters:             Fl_Widget *widget - pointer to calling widget
//                                              vois *parent - pointer to parent object
//      retruns:                        none
//
///////////////////////////////////////////////////////////
void
PPP_Modem::ppp_account_setup_cb(Fl_Widget * widget, void *parent)
{
    PPP_Modem *this_modem = (PPP_Modem *) parent;
    this_modem->_acct->show();
}

///////////////////////////////////////////////////////////
//
//      function:               PPP_Modem::get_config()
//      description:    get config values from file
//      parameters:             none
//      returns:                        none
//
///////////////////////////////////////////////////////////
void
PPP_Modem::get_configs()
{
    FILE *fp;
    char buf[MAX_LINE_LEN];
    char *p;
    char *configs[MAX_ACCOUNTS];

    if ((fp = fopen(CONFIG_FILE, "r")) == NULL) {
	return;
    }
    int idx = 0;
    for (idx = 0; idx < MAX_ACCOUNTS; idx++) {
	configs[idx] = NULL;
    }
    idx = 0;
    while (fgets(buf, sizeof(buf) - 1, fp) != NULL) {
	if (MAX_ACCOUNTS < idx) {
	    break;
	}
	if (buf[0] == '[') {
	    p = buf;
	    p++;
	    configs[idx] = (char *) calloc(strlen(p) - 1, sizeof(char));
	    strncpy(configs[idx], p, strlen(p) - 2);
	    idx++;
	}
    }
    fclose(fp);

    for (idx = 0; NULL != configs[idx]; idx++) {
	ppp_config_choice->add(configs[idx]);
    }
    ppp_config_choice->value(0);
}

///////////////////////////////////////////////////////////
//
//      function:               PPP_Modem::get_devices()
//      description:    get devices from system
//      parameters:             none
//      returns:                        none
//
///////////////////////////////////////////////////////////
void
PPP_Modem::get_devices()
{
    ppp_count = MAX_PPP_DEVS;
    pix_comm_get_if_list(PIX_COMM_TYPE_PPP, ppp_list, &ppp_count);
}

/////////////////////////////////////////////////////////////
//
//      functoin:               PPP_Modem::get_accounts()
//      description:    fill the accounts chi\oice menu from account file
//      parameters:             none
//      returns:                        none
//
////////////////////////////