static void
pid_open(void)
{
int ret;
unsigned int i;
char pidstring[20];
if ((Pidfd = open(PIDNAME, PIDOFLAG, PIDMODE)) == -1) {
logmessage(pidopenmsg);
error(E_CREAT, EXIT | NOCORE | NO_MSG);
}
if (lockf(Pidfd, 2, 0L) == -1) {
logmessage(pidlockmsg);
logexit(1, badstart);
}
Pid = getpid();
i = sprintf(pidstring, "%ld", Pid) + 1;
ftruncate(Pidfd, 0);
while ((ret = write(Pidfd, pidstring, i)) != i) {
if (errno == EINTR)
continue;
if (ret < 0)
sys_error(E_PIDWRITE, EXIT);
else
error(E_PIDWRITE, EXIT);
}
}
static void
init_files(void)
{
close(0);
if ((Acceptfd = open("/dev/null", O_RDWR)) != 0) {
logmessage("Trouble opening /dev/null");
sys_error(E_SYS_ERROR, EXIT | NOCORE);
}
close(1);
if ((Sacpipefd = open(SACPIPE, O_RDWR|O_NDELAY)) != 1) {
logmessage(sacopenmsg);
error(E_CREAT, EXIT | NOCORE | NO_MSG);
}
close(2);
if ((Pmpipefd = open(PMPIPE, O_RDWR|O_NDELAY)) != 2) {
logmessage(pmopenmsg);
error(E_CREAT, EXIT | NOCORE | NO_MSG);
}
close(3);
if ((Passfd = dup(Acceptfd)) != 3) {
logmessage("Trouble duping /dev/null");
sys_error(E_SYS_ERROR, EXIT | NOCORE);
}
}
/*--------------------------------------------------------------------------*/
int NetworkClient::NetworkHandler(void)
{
char buffer[1024];
int ret;
// read data from the client to the current offset in our recv buffer
ret = recv(netsock,&buffer,sizeof(buffer),0);
// if the client closed the connection return zero
// to let the server thread know we're done
if (ret == 0) return(0);
// return of less than zero and we log the error
// and let the server thread know we're done
if (ret < 0)
{
logmessage(LOG_ERR,"Error %d returned from recv(%s)\n",errno,netname);
return(0);
}
buffer[ret] = 0;
logmessage(LOG_DEBUG,"NETCLIENT MESSAGE: %s = %s\n",netname,buffer);
return(1);
}
int start_auth_kabinet(void)
{
int ret;
char *gateip = nvram_safe_get("wan_heartbeat_x");
char *passwd = nvram_safe_get("wan_auth_pass");
stop_auth_kabinet();
if ( !passwd[0] )
{
logmessage("lanauth", "password is empty, unable to start!");
return -1;
}
if (inet_addr_(gateip) != INADDR_ANY)
{
ret = eval("/usr/sbin/lanauth", "-s", gateip, "-p", passwd);
}
else
{
ret = eval("/usr/sbin/lanauth", "-p", passwd);
}
if (ret == 0)
{
logmessage("lanauth", "start authentication...");
}
return ret;
}
int
launch_wan_modem_ras(int unit)
{
char node_name[16] = {0};
char call_file[16];
char call_path[32];
snprintf(call_file, sizeof(call_file), "modem.wan%d", unit);
snprintf(call_path, sizeof(call_path), "%s/%s", PPP_PEERS_DIR, call_file);
mkdir_if_none(PPP_PEERS_DIR);
unlink(call_path);
if (get_modem_node_ras(node_name, NULL)) {
if (write_pppd_ras_conf(call_path, node_name, unit)) {
logmessage(LOGNAME, "select RAS modem interface %s to pppd", node_name);
return eval("/usr/sbin/pppd", "call", call_file);
}
}
logmessage(LOGNAME, "unable to open RAS modem script!");
return 1;
}
static void *
handleServer(void *ptr)
{
struct handler *handler;
struct client *c;
int32_t op;
c = (struct client *)ptr;
while(1) {
ret32(c, op);
handler = find_op(op);
if (handler == NULL) {
logmessage(c, __FILE__, __LINE__, 0,
"op %d not supported", (int)op);
exit(1);
}
logmessage(c, __FILE__, __LINE__, 0,
"---> Got op %s from server %s",
handler->name, c->servername);
if ((handler->func)(handler->op, c))
break;
}
return NULL;
}
void find_backup_mac_date(char *mpname)
{
DIR *dir;
struct dirent *ptr;
char dir_path[80];
char backup_path[80];
char mac_name[48];
char mp_name[48];
char test_log[100];
char change[] = "\n";
sprintf(mp_name,"%s", mpname);
write_timemachine_tokeninfo(mp_name);
sprintf(dir_path,"%s/%s", mpname, TIMEMACHINE_BACKUP_NAME);
sprintf(test_log,"dir_path = %s",dir_path);
logmessage("Timemachine", test_log);
if(!(dir = opendir(dir_path)))
return;
while((ptr = readdir(dir))!=NULL)
{
if (!strncmp(ptr->d_name, "loop", 4) ||
!strncmp(ptr->d_name, "mtdblock", 8) ||
!strncmp(ptr->d_name, "ram", 3) ||
!strcmp(ptr->d_name, ".AppleDouble")||
!strcmp(ptr->d_name, ".") ||
!strcmp(ptr->d_name, "..")
)
continue;
sprintf(backup_path,"%s/%s", dir_path, ptr->d_name);
sprintf(mac_name,"%s", ptr->d_name);
sprintf(test_log,"mac_name = %s",mac_name);
logmessage("Timemachine", test_log);
write_timemachine_tokeninfo(mac_name);
}
closedir(dir);
//find date
char history_file[128];
char line[256], string_line_tmp[96], backup_time[48], backup_time_t[48], *string_line;
sprintf(history_file,"%s/com.apple.TimeMachine.SnapshotHistory.plist", backup_path);
FILE *fp_t;
if ((fp_t = fopen(history_file, "r")) != NULL)
while (fgets(line, sizeof(line), fp_t))
{
if ((string_line = strstr(line, "<string>")) != NULL){
sprintf(string_line_tmp,"%s",string_line);
sscanf(string_line_tmp, "<string>%s</string>", backup_time_t);
strncpy(backup_time, backup_time_t, 17);
//sprintf(test_log,"backup_time = %s",backup_time);
//logmessage("Timemachine", test_log);
write_timemachine_tokeninfo(backup_time);
}
}
if (fp_t)
fclose(fp_t);
write_timemachine_tokeninfo(change);
}
void run_dms(int force_rescan)
{
int db_rescan_mode;
unsigned char mac_bin[ETHER_ADDR_LEN] = {0};
char mac_str[16];
char *apps_name = "Media Server";
char *link_path = "/mnt/minidlna";
char *conf_path = "/etc/minidlna.conf";
char *dest_dir = ".dms";
char *minidlna_argv[] = {
"/usr/bin/minidlnad",
"-f", conf_path,
"-s", NULL,
NULL, /* -U */
NULL
};
if (!nvram_match("apps_dms", "1"))
return;
if (!is_dms_support())
return;
if (is_dms_run())
return;
unlink(link_path);
if (!create_mp_link(dest_dir, link_path, 0))
{
if (!create_mp_link(dest_dir, link_path, 1))
{
logmessage(apps_name, "Cannot start: unable to create DB dir (/%s) on any volumes!", dest_dir);
return;
}
}
update_minidlna_conf(link_path, conf_path);
ether_atoe(nvram_safe_get("il0macaddr"), mac_bin);
minidlna_argv[4] = ether_etoa3(mac_bin, mac_str);
db_rescan_mode = nvram_get_int("dlna_rescan");
if (force_rescan || db_rescan_mode == 2)
minidlna_argv[5] = "-R";
else if (db_rescan_mode == 1)
minidlna_argv[5] = "-U";
_eval(minidlna_argv, NULL, 0, NULL);
if (is_dms_run())
logmessage(apps_name, "daemon is started");
}
/* @return:
* 0: success
* -1: invalid parameter
* 1: wait pending rc_service timeout
*/
static int notify_rc_internal(const char *event_name, bool do_wait, int wait)
{
int i;
char p1[16], p2[16];
if (!event_name || wait < 0)
return -1;
psname(nvram_get_int("rc_service_pid"), p1, sizeof(p1));
psname(getpid(), p2, sizeof(p2));
_dprintf("%s %d:notify_rc: %s\n", p2, getpid(), event_name);
logmessage("rc_service", "%s %d:notify_rc %s", p2, getpid(), event_name);
i=wait;
int first_try = 1, got_right = 1;
while ((!nvram_match("rc_service", "")) && (i-- > 0)) {
if(first_try){
logmessage("rc_service", "%s is waitting %s...", event_name, nvram_safe_get("rc_service"));
first_try = 0;
}
_dprintf("%d %s: wait for previous script(%d/%d): %s %d %s.\n", getpid(), p2, i, wait, nvram_safe_get("rc_service"), nvram_get_int("rc_service_pid"), p1);
sleep(1);
if(i <= 0)
got_right = 0;
}
if(!got_right){
logmessage("rc_service", "skip the event: %s.", event_name);
_dprintf("rc_service: skip the event: %s.\n", event_name);
return 1;
}
nvram_set("rc_service", event_name);
nvram_set_int("rc_service_pid", getpid());
kill(1, SIGUSR1);
if(do_wait)
{
i = wait;
while((nvram_match("rc_service", (char *)event_name))&&(i-- > 0)) {
_dprintf("%s %d: waiting after %d/%d.\n", event_name, getpid(), i, wait);
sleep(1);
}
}
return 0;
}
int ntp_timesync(void)
{
time_t now;
struct tm local;
if (sync_interval != -1)
{
sync_interval--;
if (nvram_match("ntp_ready", "1") && !ntp_first_refresh)
{
ntp_first_refresh = 1;
if (!nvram_match("ddns_updated", "1"))
{
logmessage("RT-N56U", "[start ddns] ntp timesync");
start_ddns();
}
sync_interval = 4320;
logmessage("ntp client", "time is synchronized to %s", nvram_safe_get("ntp_server0"));
reset_svc_radio_time();
}
else if (sync_interval == 0)
{
time(&now);
localtime_r(&now, &local);
/* More than 2000 */
if (local.tm_year > 100)
{
sync_interval = 4320;
logmessage("ntp client", "time is synchronized to %s", nvram_safe_get("ntp_server0"));
system("date");
reset_svc_radio_time();
}
else
{
// sync_interval = 6;
sync_interval = 3;
}
refresh_ntpc();
}
}
}
void EndpointAppPBX::action_init_efi(void)
{
// int language = e_ext.vbox_language;
// struct route_param *rparam;
struct lcr_msg *message;
struct port_list *portlist = ea_endpoint->ep_portlist;
/* if no caller id */
if (e_callerinfo.id[0] == '\0') {
/* facility rejected */
message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_DISCONNECT);
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
message->param.disconnectinfo.cause = CAUSE_FACILITYREJECTED;
message_put(message);
logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
new_state(EPOINT_STATE_OUT_DISCONNECT);
set_tone(portlist,"cause_22");
return;
}
/* connect */
new_state(EPOINT_STATE_CONNECT);
/* initialize the vbox */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d) initializing efi\n", ea_endpoint->ep_serial);
e_efi_state = EFI_STATE_HELLO;
set_tone_efi("hello");
e_efi_digit = 0;
}
static void
on_server_client_connect(int is_tun)
{
FILE *fp;
char *common_name = safe_getenv("common_name");
char *peer_addr_r = safe_getenv("trusted_ip");
char *peer_addr_l = safe_getenv("ifconfig_pool_remote_ip");
char *dev_ifname = safe_getenv("dev");
const char *script_name = VPN_SERVER_UPDOWN_SCRIPT;
#if defined (USE_IPV6)
if (!is_valid_ipv4(peer_addr_r))
peer_addr_r = safe_getenv("trusted_ip6");
#endif
if (strlen(dev_ifname) == 0)
dev_ifname = (is_tun) ? IFNAME_SERVER_TUN : IFNAME_SERVER_TAP;
logmessage(SERVER_LOG_NAME, "peer %s (%s) connected - local IP: %s",
peer_addr_r, common_name, peer_addr_l);
fp = fopen(VPN_SERVER_LEASE_FILE, "a+");
if (fp) {
fprintf(fp, "%s %s %s %s\n", "-", peer_addr_l, peer_addr_r, common_name);
fclose(fp);
}
if (check_if_file_exist(script_name))
doSystem("%s %s %s %s %s %s", script_name, "up", dev_ifname, peer_addr_l, peer_addr_r, common_name);
}
void stop_timemachine()
{
stop_afpd();
stop_cnid_metad();
restart_mdns();
logmessage("Timemachine", "daemon is stopped");
}
w_rc_t
svas_layer_init::_serve_devices(svas_server *temp)
{
char b[200];
ostrstream lmsg(b, sizeof(b));
dassert(temp);
if(opt_serve_array==0) return RCOK;
int i;
w_rc_t rc;
char *devicename=0;
for(i=0; i<opt_serve_array_used; i++) {
devicename = opt_serve_array[i];
dassert(devicename != 0);
DBG(<<"about to serve " << devicename);
if(temp->serve(devicename) != SVAS_OK) {
rc = RC(OPT_BadValue);
lmsg << "svas_serve: " << devicename << ": " << rc << endl << ends;
}
delete devicename;
opt_serve_array[i] = 0;
}
delete opt_serve_array;
opt_serve_array_used =0;
opt_serve_array_alloced =0;
if(rc) {
logmessage(lmsg.str());
}
return rc;
}
static void
ez_action_usb_saferemoval(void)
{
logmessage("watchdog", "Perform ez-button safe-removal USB...");
safe_remove_usb_device(0, NULL);
}
static void
ez_action_shutdown(void)
{
logmessage("watchdog", "Perform ez-button %s...", "shutdown");
sys_stop();
}
static void
ez_action_shutdown(void)
{
logmessage("watchdog", "Perform ez-button shutdown...");
notify_rc("shutdown_prepare");
}
static void
ez_action_change_wifi2(void)
{
int i_radio_state;
if (get_enabled_radio_rt())
{
i_radio_state = 0;
}
else
{
i_radio_state = 1;
update_svc_status_wifi2();
}
nvram_wlan_set_int(0, "radio_x", i_radio_state);
logmessage("watchdog", "Perform ez-button %s %s %s", (i_radio_state) ? "enable" : "disable", "2.4GHz", "radio");
#if defined(USE_RT3352_MII)
mlme_radio_rt(i_radio_state);
#else
restart_wifi_rt(i_radio_state, 0);
#endif
}
static void
refresh_ntp(void)
{
char *svcs[] = { "ntpd", NULL };
char *ntp_addr[2], *ntp_server;
kill_services(svcs, 3, 1);
ntp_addr[0] = nvram_safe_get("ntp_server0");
ntp_addr[1] = nvram_safe_get("ntp_server1");
if (strlen(ntp_addr[0]) < 3)
ntp_addr[0] = ntp_addr[1];
else if (strlen(ntp_addr[1]) < 3)
ntp_addr[1] = ntp_addr[0];
if (strlen(ntp_addr[0]) < 3) {
ntp_addr[0] = "pool.ntp.org";
ntp_addr[1] = ntp_addr[0];
}
ntp_server = (ntpc_server_idx) ? ntp_addr[1] : ntp_addr[0];
ntpc_server_idx = (ntpc_server_idx + 1) % 2;
eval("/usr/sbin/ntpd", "-qt", "-S", NTPC_DONE_SCRIPT, "-p", ntp_server);
logmessage("NTP Client", "Synchronizing time to %s.", ntp_server);
}
int wpacli_main(int argc, char **argv)
{
if (argc < 3)
return EINVAL;
if (!argv[1])
return EINVAL;
if (nvram_invmatch("wan_auth_mode", "2"))
return 0;
if (strncmp(argv[2], "EAP-SUCCESS", 11) != 0)
{
logmessage("eapol-md5", "%s", argv[2]);
}
#if 0
/* disable DHCP lease force renew by issues with some ISP (lease losted after force renew) */
else if (nvram_match("wan0_proto", "dhcp"))
{
/* Renew DHCP lease */
system("killall -SIGUSR1 udhcpc");
}
#endif
return 0;
}
unsigned long SysWaitEventSem(unsigned char *name,
unsigned long numargs,
RXSTRING args[],
char *queuename,
RXSTRING *retstr)
{
unsigned long rc;
unsigned long timeout = SEM_INDEFINITE_WAIT; /* timeout value default */
HEV handle = NULL; /* mutex handle */
#ifdef DLOGGING
logmessage(__func__);
#endif
if (numargs < 1 || numargs > 2 || !RXVALIDSTRING(args[0]))
return INVALID_ROUTINE;
if (numargs == 2) {
if (!string2ulong(args[1].strptr, &timeout)) return INVALID_ROUTINE;
}
if (!string2ulong(args[0].strptr, &handle)) return INVALID_ROUTINE;
rc = DosWaitEventSem(handle, timeout);
RETVAL(rc)
}
static void
on_server_client_disconnect(int is_tun)
{
FILE *fp1, *fp2;
char ifname[16], addr_l[64], addr_r[64], peer_name[64];
char *clients_l1 = VPN_SERVER_LEASE_FILE;
char *clients_l2 = "/tmp/.vpns.leases";
char *common_name = safe_getenv("common_name");
char *peer_addr_r = safe_getenv("trusted_ip");
char *peer_addr_l = safe_getenv("ifconfig_pool_remote_ip");
uint64_t llsent = strtoll(safe_getenv("bytes_sent"), NULL, 10);
uint64_t llrecv = strtoll(safe_getenv("bytes_received"), NULL, 10);
logmessage(SERVER_LOG_NAME, "peer %s (%s) disconnected, sent: %llu KB, received: %llu KB",
peer_addr_r, common_name, llsent / 1024, llrecv / 1024);
fp1 = fopen(clients_l1, "r");
fp2 = fopen(clients_l2, "w");
if (fp1) {
while(fscanf(fp1, "%s %s %s %[^\n]\n", ifname, addr_l, addr_r, peer_name) == 4) {
if (strcmp(peer_addr_r, addr_r) != 0 || strcmp(peer_addr_l, addr_l) != 0) {
if (fp2)
fprintf(fp2, "%s %s %s %s\n", ifname, addr_l, addr_r, peer_name);
}
}
fclose(fp1);
}
if (fp2) {
fclose(fp2);
rename(clients_l2, clients_l1);
unlink(clients_l2);
}
}
int start_dhcp6c(char *wan_ifname)
{
FILE *fp;
int wan6_dhcp, dns6_auto, lan6_auto, ia_id, sla_id, sla_len;
char *conf_file = "/etc/dhcp6c.conf";
wan6_dhcp = nvram_get_int("ip6_wan_dhcp");
dns6_auto = nvram_get_int("ip6_dns_auto");
lan6_auto = nvram_get_int("ip6_lan_auto");
if (!wan6_dhcp && !dns6_auto && !lan6_auto)
return 1;
ia_id = 0;
sla_id = 1;
sla_len = 0; /* auto prefix always /64 */
fp = fopen(conf_file, "w");
if (!fp) {
perror(conf_file);
return -1;
}
fprintf(fp, "interface %s {\n", wan_ifname);
if (wan6_dhcp)
fprintf(fp, " send ia-na %d;\n", ia_id);
if (lan6_auto)
fprintf(fp, " send ia-pd %d;\n", ia_id);
if (wan6_dhcp || lan6_auto)
fprintf(fp, " send rapid-commit;\n");
else
fprintf(fp, " information-only ;\n"); /* space needed for dhcp6c port in busybox */
if (dns6_auto)
fprintf(fp, " request domain-name-servers;\n");
fprintf(fp,
" script \"%s\";\n"
"};\n",
SCRIPT_DHCP6C_WAN
);
if (wan6_dhcp)
fprintf(fp, "id-assoc na %d { };\n", ia_id);
if (lan6_auto)
fprintf(fp,
"id-assoc pd %d {\n"
" prefix-interface %s {\n"
" sla-id %d;\n"
" sla-len %d;\n"
" };\n"
"};\n",
ia_id,
IFNAME_BR,
sla_id,
sla_len
);
fclose(fp);
logmessage("DHCPv6 WAN Client", "starting on wan (%s) ...", wan_ifname);
return eval("/sbin/dhcp6c", "-D", "LL", wan_ifname);
}
static int
ncm_control_network(const char* control_node, int is_start)
{
FILE *fp;
int result = 1;
char node_path[32], node_msg[64];
if (is_start) {
char *apn = nvram_safe_get("modem_apn");
if (strlen(apn) < 1)
apn = "internet";
snprintf(node_msg, sizeof(node_msg), "AT^NDISDUP=1,%d,\"%s\"\r\n", 1, apn);
} else
snprintf(node_msg, sizeof(node_msg), "AT^NDISDUP=1,%d\r\n", 0);
snprintf(node_path, sizeof(node_path), "/dev/%s", control_node);
fp = fopen(node_path, "wb");
if (fp) {
if (fwrite(node_msg, 1, strlen(node_msg), fp) > 0)
result = 0;
fclose(fp);
}
node_msg[strlen(node_msg) - 2] = 0; /* get rid of '\r\n' */
if (!result) {
if (is_start)
sleep(1);
} else {
logmessage(LOGNAME, "NCM message %s to node %s: %s", node_msg, node_path, "FAILED!");
}
return result;
}
static void sighandler(int signum)
{
if (signum == SIGINT || signum == SIGTERM) {
unlink(pidpath);
logmessage("Closing cleanly.\n");
exit(0);
}
}
static int
HandleOP(AcquireCreds)
{
char *name, *password;
int32_t gsm_error, flags, handle = 0;
krb5_principal principal = NULL;
krb5_get_init_creds_opt *opt = NULL;
krb5_error_code ret;
retstring(c, name);
retstring(c, password);
ret32(c, flags);
logmessage(c, __FILE__, __LINE__, 0,
"username: %s password: %s", name, password);
ret = krb5_parse_name(context, name, &principal);
if (ret) {
gsm_error = convert_krb5_to_gsm(ret);
goto out;
}
ret = krb5_get_init_creds_opt_alloc (context, &opt);
if (ret)
krb5_err(context, 1, ret, "krb5_get_init_creds_opt_alloc");
krb5_get_init_creds_opt_set_pa_password(context, opt, password, NULL);
gsm_error = acquire_cred(c, principal, opt, &handle);
out:
logmessage(c, __FILE__, __LINE__, 0,
"AcquireCreds handle: %d return code: %d", handle, gsm_error);
if (opt)
krb5_get_init_creds_opt_free (context, opt);
if (principal)
krb5_free_principal(context, principal);
free(name);
free(password);
put32(c, gsm_error);
put32(c, handle);
return 0;
}
/*--------------------------------------------------------------------------*/
NetworkClient::~NetworkClient(void)
{
logmessage(LOG_DEBUG,"NETCLIENT GOODBYE: %s\n",netname);
// shutdown and close the socket
shutdown(netsock,SHUT_RDWR);
close(netsock);
}
void syslog(int priority, const char *format, ...) {
DBG(("liblogfaf: syslog(%d, %s)\n", priority, format));
va_list ap;
char str[MAX_MESSAGE_LEN];
va_start(ap, format);
vsnprintf(str, MAX_MESSAGE_LEN, format, ap);
va_end(ap);
logmessage(&shared_data, priority, str);
}
static void
ez_action_usb_saferemoval(void)
{
#if (BOARD_NUM_USB_PORTS > 0)
logmessage("watchdog", "Perform ez-button %s...", "safe-removal USB");
safe_remove_usb_device(0, NULL, 1);
#endif
}
static int
bound(void) // udhcpc bound here, also call wanup
{
char *wan_ifname = safe_getenv("interface");
char *value;
char tmp[100], prefix[] = "wanXXXXXXXXXX_";
int unit;
if ((unit = wan_ifunit(wan_ifname)) < 0)
strcpy(prefix, "wanx_");
else
snprintf(prefix, sizeof(prefix), "wan%d_", unit);
if ((value = getenv("ip")))
nvram_set(strcat_r(prefix, "ipaddr", tmp), trim_r(value));
if ((value = getenv("subnet")))
nvram_set(strcat_r(prefix, "netmask", tmp), trim_r(value));
if ((value = getenv("router")))
nvram_set(strcat_r(prefix, "gateway", tmp), trim_r(value));
if ((value = getenv("dns")))
nvram_set(strcat_r(prefix, "dns", tmp), trim_r(value));
if ((value = getenv("wins")))
nvram_set(strcat_r(prefix, "wins", tmp), trim_r(value));
nvram_set(strcat_r(prefix, "routes", tmp), getenv("routes"));
nvram_set(strcat_r(prefix, "msroutes", tmp), getenv("msroutes"));
#if 0
if ((value = getenv("hostname")))
sethostname(trim_r(value), strlen(value) + 1);
#endif
if ((value = getenv("domain")))
nvram_set(strcat_r(prefix, "domain", tmp), trim_r(value));
if ((value = getenv("lease"))) {
nvram_set(strcat_r(prefix, "lease", tmp), trim_r(value));
expires(wan_ifname, atoi(value));
}
ifconfig(wan_ifname, IFUP,
nvram_safe_get(strcat_r(prefix, "ipaddr", tmp)),
nvram_safe_get(strcat_r(prefix, "netmask", tmp)));
spinlock_lock(SPINLOCK_DHCPRenew);
nvram_set("dhcp_renew", "0"); // for detectWAN
spinlock_unlock(SPINLOCK_DHCPRenew);
wan_up(wan_ifname);
logmessage("dhcp client", "%s IP: %s from %s (prefix: %s)",
udhcpstate,
nvram_safe_get(strcat_r(prefix, "ipaddr", tmp)),
nvram_safe_get(strcat_r(prefix, "gateway", tmp)), prefix);
wanmessage("");
dprintf("done\n");
return 0;
}
