1/* 2 nvram control 3 */ 4 5#if EMBEDDED_EANBLE 6#include "nvram_control.h" 7#include "log.h" 8 9#if defined APP_IPKG 10#include<stdlib.h> //for system cmd by zero added 11#elif defined USE_TCAPI 12#include <utils.h> 13#include <shutils.h> 14#include <shared.h> 15#include "libtcapi.h" 16#include "tcapi.h" 17#else 18#include <utils.h> 19#include <shutils.h> 20#include <shared.h> 21#endif 22 23#ifdef USE_TCAPI 24#define WEBDAV "AiCloud_Entry" 25#define APPS "Apps_Entry" 26#define DDNS "Ddns_Entry" 27#define SAMBA "Samba_Entry" 28#define ACCOUNT "Account_Entry0" 29#define SYSINFO "SysInfo_Entry" 30#define INFOETH "Info_Ether" 31#define DEVICEINFO "DeviceInfo" 32#define TIMEZONE "Timezone_Entry" 33#define FIREWALL "Firewall_Entry" 34#define DDNS_ENANBLE_X "Active" // #define DDNS_ENANBLE_X "ddns_enable_x" 35#define DDNS_SERVER_X "SERVERNAME" // #define DDNS_SERVER_X "ddns_server_x" 36#define DDNS_HOST_NAME_X "MYHOST" // #define DDNS_HOST_NAME_X "ddns_hostname_x" 37#define WEBDAV_SMB_PC "webdav_smb_pc" 38#define PRODUCT_ID "productid" 39#define COMPUTER_NAME "NetBiosName" 40#define ACC_LIST "acc_list" 41#define AICLOUD_ACC_LIST "aicloud_acc_list" 42#define AICLOUD_ACC_INVITE_LIST "aicloud_acc_invite_list" 43#define ACC_WEBDAVPROXY "acc_webdavproxy" 44#define ST_SAMBA_MODE "st_samba_mode" 45#define ST_SAMBA_FORCE_MODE "st_samba_force_mode" 46#define HTTP_USERNAME "username" // #define HTTP_USERNAME "http_username" 47#define HTTP_PASSWD "web_passwd" // #define HTTP_PASSWD "http_passwd" 48#define WEBDAVAIDISK "webdav_aidisk" 49#define WEBDAVPROXY "webdav_proxy" 50#define SHARELINK "share_link" 51#define ETHMACADDR "mac" // #define ETHMACADDR "et0macaddr" 52#define FIRMVER "FwVer" // #define FIRMVER "firmver" 53#define BUILDNO "buildno" 54#define ST_WEBDAV_MODE "st_webdav_mode" 55#define WEBDAV_HTTP_PORT "webdav_http_port" 56#define WEBDAV_HTTPS_PORT "webdav_https_port" 57#define MISC_HTTP_X "misc_http_x" 58#define MISC_HTTP_PORT "misc_httpport_x" 59#define MISC_HTTPS_PORT "misc_httpsport_x" 60#define ENABLE_WEBDAV_CAPTCHA "enable_webdav_captcha" 61#define ENABLE_WEBDAV_LOCK "enable_webdav_lock" 62#define WEBDAV_ACC_LOCK "webdav_acc_lock" 63#define WEBDAV_LOCK_INTERVAL "webdav_lock_interval" 64#define WEBDAV_LOCK_TIMES "webdav_lock_times" 65#define WEBDAV_LAST_LOGININFO "webdav_last_login_info" 66#define WEBS_STATE_INFO "webs_state_info" 67#define WEBS_STATE_ERROR "webs_state_error" 68#define SHARE_LINK_PARAM "share_link_param" 69#define SHARE_LINK_RESULT "share_link_result" 70#define TIME_ZONE_X "TZ" 71#define SWPJVERNO "swpjverno" 72#define EXTENDNO "extendno" 73#define DMS_ENABLE "dms_enable" 74#define MS_DLNA "ms_dlna" 75#define MS_PATH "ms_path" 76#define DMS_DBCWD "dms_dbcwd" 77#define DMS_DIR "dms_dir" 78#define HTTPS_CRT_CN "https_crt_cn" 79#define ODMPID "odmpid" 80#define APPS_SQ "apps_sq" 81#else 82#define DDNS_ENANBLE_X "ddns_enable_x" 83#define DDNS_SERVER_X "ddns_server_x" 84#define DDNS_HOST_NAME_X "ddns_hostname_x" 85#define WEBDAV_SMB_PC "webdav_smb_pc" 86#define PRODUCT_ID "productid" 87#define COMPUTER_NAME "computer_name" 88#define ACC_LIST "acc_list" 89#define AICLOUD_ACC_LIST "aicloud_acc_list" 90#define AICLOUD_ACC_INVITE_LIST "aicloud_acc_invite_list" 91#define ACC_WEBDAVPROXY "acc_webdavproxy" 92#define ST_SAMBA_MODE "st_samba_mode" 93#define ST_SAMBA_FORCE_MODE "st_samba_force_mode" 94#define HTTP_USERNAME "http_username" 95#define HTTP_PASSWD "http_passwd" 96#define WEBDAVAIDISK "webdav_aidisk" 97#define WEBDAVPROXY "webdav_proxy" 98#define SHARELINK "share_link" 99#define ETHMACADDR "lan_hwaddr" 100#define FIRMVER "firmver" 101#define BUILDNO "buildno" 102#define ST_WEBDAV_MODE "st_webdav_mode" 103#define WEBDAV_HTTP_PORT "webdav_http_port" 104#define WEBDAV_HTTPS_PORT "webdav_https_port" 105#define HTTP_ENABLE "http_enable" 106#define LAN_HTTPS_PORT "https_lanport" 107#define MISC_HTTP_X "misc_http_x" 108#define MISC_HTTP_PORT "misc_httpport_x" 109#define MISC_HTTPS_PORT "misc_httpsport_x" 110#define ENABLE_WEBDAV_CAPTCHA "enable_webdav_captcha" 111#define ENABLE_WEBDAV_LOCK "enable_webdav_lock" 112#define WEBDAV_ACC_LOCK "webdav_acc_lock" 113#define WEBDAV_LOCK_INTERVAL "webdav_lock_interval" 114#define WEBDAV_LOCK_TIMES "webdav_lock_times" 115#define WEBDAV_LAST_LOGININFO "webdav_last_login_info" 116#define WEBS_STATE_INFO "webs_state_info" 117#define WEBS_STATE_ERROR "webs_state_error" 118#define SHARE_LINK_PARAM "share_link_param" 119#define SHARE_LINK_RESULT "share_link_result" 120#define TIME_ZONE_X "time_zone_x" 121#define SWPJVERNO "swpjverno" 122#define EXTENDNO "extendno" 123#define DMS_ENABLE "dms_enable" 124#define MS_DLNA "ms_dlna" 125#define DMS_DBCWD "dms_dbcwd" 126#define DMS_DIR "dms_dir" 127#define HTTPS_CRT_CN "https_crt_cn" 128#define HTTPS_CRT_SAVE "https_crt_save" 129#define HTTPS_CRT_FILE "https_crt_file" 130#define ODMPID "odmpid" 131#define APPS_SQ "apps_sq" 132#endif 133 134#define DBE 0 135 136#if defined APP_IPKG 137 138static const char base64_xlat[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 139 140 141int base64_encode(const unsigned char *in, char *out, int inlen) 142{ 143 char *o; 144 145 o = out; 146 while (inlen >= 3) { 147 *out++ = base64_xlat[*in >> 2]; 148 *out++ = base64_xlat[((*in << 4) & 0x3F) | (*(in + 1) >> 4)]; 149 ++in; // note: gcc complains if *(++in) 150 *out++ = base64_xlat[((*in << 2) & 0x3F) | (*(in + 1) >> 6)]; 151 ++in; 152 *out++ = base64_xlat[*in++ & 0x3F]; 153 inlen -= 3; 154 } 155 if (inlen > 0) { 156 *out++ = base64_xlat[*in >> 2]; 157 if (inlen == 2) { 158 *out++ = base64_xlat[((*in << 4) & 0x3F) | (*(in + 1) >> 4)]; 159 ++in; 160 *out++ = base64_xlat[((*in << 2) & 0x3F)]; 161 } 162 else { 163 *out++ = base64_xlat[(*in << 4) & 0x3F]; 164 *out++ = '='; 165 } 166 *out++ = '='; 167 } 168 return out - o; 169} 170 171 172int base64_decode_t(const char *in, unsigned char *out, int inlen) 173{ 174 char *p; 175 int n; 176 unsigned long x; 177 unsigned char *o; 178 char c; 179 180 o = out; 181 n = 0; 182 x = 0; 183 while (inlen-- > 0) { 184 if (*in == '=') break; 185 if ((p = strchr(base64_xlat, c = *in++)) == NULL) { 186// printf("ignored - %x %c\n", c, c); 187 continue; // note: invalid characters are just ignored 188 } 189 x = (x << 6) | (p - base64_xlat); 190 if (++n == 4) { 191 *out++ = x >> 16; 192 *out++ = (x >> 8) & 0xFF; 193 *out++ = x & 0xFF; 194 n = 0; 195 x = 0; 196 } 197 } 198 if (n == 3) { 199 *out++ = x >> 10; 200 *out++ = (x >> 2) & 0xFF; 201 } 202 else if (n == 2) { 203 *out++ = x >> 4; 204 } 205 return out - o; 206} 207 208int base64_encoded_len(int len) 209{ 210 return ((len + 2) / 3) * 4; 211} 212 213int base64_decoded_len(int len) 214{ 215 return ((len + 3) / 4) * 3; 216} 217 218static inline char * strcat_r(const char *s1, const char *s2, char *buf) 219{ 220 strcpy(buf, s1); 221 strcat(buf, s2); 222 return buf; 223} 224 225char *nvram_get(char *name); 226#define FW_CREATE 0 227#define FW_APPEND 1 228#define FW_NEWLINE 2 229 230unsigned long f_size(const char *path) // 4GB-1 -1 = error 231{ 232 struct stat st; 233 if (stat(path, &st) == 0) return st.st_size; 234 return (unsigned long)-1; 235} 236 237int f_write(const char *path, const void *buffer, int len, unsigned flags, unsigned cmode) 238{ 239 static const char nl = '\n'; 240 int f; 241 int r = -1; 242 mode_t m; 243 244 m = umask(0); 245 if (cmode == 0) cmode = 0666; 246 if ((f = open(path, (flags & FW_APPEND) ? (O_WRONLY|O_CREAT|O_APPEND) : (O_WRONLY|O_CREAT|O_TRUNC), cmode)) >= 0) { 247 if ((buffer == NULL) || ((r = write(f, buffer, len)) == len)) { 248 if (flags & FW_NEWLINE) { 249 if (write(f, &nl, 1) == 1) ++r; 250 } 251 } 252 close(f); 253 } 254 umask(m); 255 return r; 256} 257 258int f_read(const char *path, void *buffer, int max) 259{ 260 int f; 261 int n; 262 263 if ((f = open(path, O_RDONLY)) < 0) return -1; 264 n = read(f, buffer, max); 265 close(f); 266 return n; 267} 268 269static int _f_read_alloc(const char *path, char **buffer, int max, int z) 270{ 271 unsigned long n; 272 273 *buffer = NULL; 274 if (max >= 0) { 275 if ((n = f_size(path)) != (unsigned long)-1) { 276 if (n < max) max = n; 277 if ((!z) && (max == 0)) return 0; 278 if ((*buffer = malloc(max + z)) != NULL) { 279 if ((max = f_read(path, *buffer, max)) >= 0) { 280 if (z) *(*buffer + max) = 0; 281 return max; 282 } 283 free(buffer); 284 } 285 } 286 } 287 return -1; 288} 289 290int f_read_alloc(const char *path, char **buffer, int max) 291{ 292 return _f_read_alloc(path, buffer, max, 0); 293} 294 295char *get_productid(void) 296{ 297 char *productid = nvram_get("productid"); 298 char *odmpid = nvram_get("odmpid"); 299 if(odmpid != NULL) 300 { 301 if (*odmpid) 302 productid = odmpid; 303 } 304 return productid; 305} 306 307//test{ 308 309#include <fcntl.h> 310#include <sys/mman.h> 311//#include <utils.h> 312#include <errno.h> 313 314#define NVRAM_SPACE 0x8000 315/* For CFE builds this gets passed in thru the makefile */ 316#define MAX_NVRAM_SPACE NVRAM_SPACE 317 318#define PATH_DEV_NVRAM "/dev/nvram" 319 320/* Globals */ 321static int nvram_fd = -1; 322static char *nvram_buf = NULL; 323 324int 325nvram_init(void *unused) 326{ 327 if (nvram_fd >= 0) 328 return 0; 329 330 if ((nvram_fd = open(PATH_DEV_NVRAM, O_RDWR)) < 0) 331 goto err; 332 333 /* Map kernel string buffer into user space */ 334 nvram_buf = mmap(NULL, MAX_NVRAM_SPACE, PROT_READ, MAP_SHARED, nvram_fd, 0); 335 if (nvram_buf == MAP_FAILED) { 336 close(nvram_fd); 337 nvram_fd = -1; 338 goto err; 339 } 340 341 fcntl(nvram_fd, F_SETFD, FD_CLOEXEC); 342 343 return 0; 344 345err: 346 perror(PATH_DEV_NVRAM); 347 return errno; 348} 349char *nvram_get_original(char *name); 350char *nvram_get(char *name) 351{ 352 //fprintf(stderr,"name = %s\n",name); 353 //if(!strcmp(name,"computer_name")) 354 //return nvram_get_original(name); 355 356 char tmp[100]; 357 char *value; 358 char *out; 359 size_t count = strlen(name) + 1; 360 unsigned long *off = (unsigned long *)tmp; 361 362 if (nvram_fd < 0) { 363 if (nvram_init(NULL) != 0) //return NULL; 364 { 365 return nvram_get_original(name); 366 } 367 } 368 369 if (count > sizeof(tmp)) { 370 if ((off = malloc(count)) == NULL) return NULL; 371 } 372 373 /* Get offset into mmap() space */ 374 strcpy((char *) off, name); 375 count = read(nvram_fd, off, count); 376 377 if (count == sizeof(*off)) { 378 value = &nvram_buf[*off]; 379 out = malloc(strlen(value)+1); 380 memset(out,0,strlen(value)+1); 381 sprintf(out,"%s",value); 382 } 383 else { 384 value = NULL; 385 out = NULL; 386 if (count < 0) perror(PATH_DEV_NVRAM); 387 } 388 389 if (off != (unsigned long *)tmp) free(off); 390 //fprintf(stderr,"value = %s\n",out); 391 return out; 392} 393//end test} 394 395char *nvram_get_original(char *name) 396//char *nvram_get(char *name) 397{ 398 fprintf(stderr,"name = %s\n",name); 399#if 0 400 401 if(strcmp(name,"webdav_aidisk")==0 ||strcmp(name,"webdav_proxy")==0||strcmp(name,"webdav_smb_pc")==0 402 ||strcmp(name,"share_link")==0||strcmp(name,"webdav_acc_lock")==0 403 ||strcmp(name,"webdav_last_login_info")==0||strcmp(name,"enable_webdav_lock")==0 404 ||strcmp(name,"http_passwd")==0||strcmp(name,"webdav_lock_times")==0||strcmp(name,"webdav_lock_interval")==0 405 ||strcmp(name,"ddns_hostname_x")==0||strcmp(name,"ddns_enable_x")==0||strcmp(name,"ddns_server_x")==0 406 ||strcmp(name,"share_link_param")==0||strcmp(name,"share_link_result")==0 407 ||strcmp(name,"swpjverno")==0||strcmp(name,"extendno")==0) 408 { 409#endif 410 char tmp_name[256]="/opt/etc/apps_asus_script/aicloud_nvram_check.sh"; 411 //char tmp_name[256]="/tmp/aicloud_nvram_check.sh"; 412 char *cmd_name; 413 cmd_name=(char *)malloc(sizeof(char)*(strlen(tmp_name)+strlen(name)+2)); 414 memset(cmd_name,0,sizeof(cmd_name)); 415 sprintf(cmd_name,"%s %s",tmp_name,name); 416 system(cmd_name); 417 free(cmd_name); 418 419 while(-1!=access("/tmp/aicloud_check.control",F_OK)) 420 usleep(50); 421 // } 422//#endif 423 424 FILE *fp; 425 if((fp=fopen("/tmp/webDAV.conf","r+"))==NULL) 426 { 427 return NULL; 428 } 429 char *value = NULL; 430 //value=(char *)malloc(256); 431 //memset(value,'\0',sizeof(value)); 432 int file_size = f_size("/tmp/webDAV.conf"); 433 char *tmp=(char *)malloc(sizeof(char)*(file_size+1)); 434 while(!feof(fp)){ 435 memset(tmp,'\0',sizeof(tmp)); 436 fgets(tmp,file_size+1,fp); 437 if(strncmp(tmp,name,strlen(name))==0) 438 { 439 if(tmp[strlen(tmp)-1] == 10) 440 { 441 tmp[strlen(tmp)-1]='\0'; 442 } 443 char *p=NULL; 444 p=strchr(tmp,'='); 445 p++; 446 if(p == NULL || strlen(p) == 0) 447 { 448 fclose(fp); 449 free(tmp); 450 return NULL; 451 } 452 else 453 { 454 value=(char *)malloc(strlen(p)+1); 455 memset(value,'\0',sizeof(value)); 456 strcpy(value,p); 457 if(value[strlen(value)-1]=='\n') 458 value[strlen(value)-1]='\0'; 459 } 460 461 } 462 fclose(fp); 463 free(tmp); 464 return value; 465} 466} 467char *nvram_safe_get(char *name) 468{ 469 char *p = nvram_get(name); 470 return p ? p : ""; 471} 472int nvram_set(const char *name, const char *value) 473{ 474 char *cmd; 475 476 if(value == NULL) 477 cmd=(char *)malloc(sizeof(char)*(64+strlen(name))); 478 else 479 cmd=(char *)malloc(sizeof(char)*(64+strlen(name)+strlen(value))); 480 481 memset(cmd,0,sizeof(cmd)); 482 483 sprintf(cmd,"nvram set \"%s=%s\"",name,value); 484 485 system(cmd); 486 487 free(cmd); 488 return 0; 489# if 0 490 size_t count = strlen(name) + 1; 491 char tmp[100]; 492 char *buf = tmp; 493 int ret; 494 FILE *fp; 495 char tmp_name[100]={0}; 496 /* Unset if value is NULL */ 497 if (value) count += strlen(value) + 1; 498 499 if (count > sizeof(tmp)) { 500 if ((buf = malloc(count)) == NULL) return -1; 501 } 502 503 if (value) { 504 sprintf(buf, "%s=%s", name, value); 505 } 506 else { 507 strcpy(buf, name); 508 } 509 if((fp=fopen("/tmp/webDAV.conf","r+"))==NULL) 510 { 511 return -1; 512 } 513 while(!feof(fp)){ 514 fgets(tmp_name,sizeof(tmp_name),fp); 515 if(strncmp(tmp_name,name,strlen(name))==0) 516 { 517#if 0 518 char *cmd_name; 519 if(value == NULL) 520 cmd_name=(char *)malloc(sizeof(char)*(64+2*strlen(name))); 521 else 522 cmd_name=(char *)malloc(sizeof(char)*(64+2*strlen(name)+strlen(value))); 523 memset(cmd_name,0,sizeof(cmd_name)); 524#endif 525 /* 526 if(strcmp(name,"webdav_last_login_info")==0) 527 { 528 */ 529 char tmp_name[256]="/opt/etc/apps_asus_script/aicloud_nvram_check.sh"; 530 char *cmd_name_1; 531 cmd_name_1=(char *)malloc(sizeof(char)*(strlen(tmp_name)+strlen(name)+2)); 532 memset(cmd_name_1,0,sizeof(cmd_name_1)); 533 sprintf(cmd_name_1,"%s %s",tmp_name,name); 534 system(cmd_name_1); 535 //fprintf(stderr,"cmd_name_1=%s\n",cmd_name_1); 536 free(cmd_name_1); 537 538 539#if 0 540 char value_tmp[256]={0}; 541 FILE *fp_1=fopen("/tmp/aicloud_nvram.txt","r+"); 542 fgets(value_tmp,sizeof(value_tmp),fp_1); 543 fclose(fp_1); 544 sprintf(cmd_name,"sed -i 's/^%s.*/%s=%s/g' /tmp/webDAV.conf",name,name,value_tmp); 545 system(cmd_name); 546 547 } 548 else 549 { 550 551 sprintf(cmd_name,"sed -i 's/^%s=.*/%s=%s/g' /tmp/webDAV.conf",name,name,value); 552 553 system(cmd_name); 554 } 555#endif 556 //free(cmd_name); 557 if (buf != tmp) free(buf); 558 fclose(fp); 559 return 0; 560 //return (ret == count) ? 0 : ret; 561 } 562 } 563 ret = fprintf(fp,"%s\n",buf); 564 //ret = fwrite(buf,sizeof(buf),1,fp); 565 566 if (buf != tmp) free(buf); 567 fclose(fp); 568 return (ret == count) ? 0 : ret; 569#endif 570} 571 572int nvram_commit(void) 573{ 574#if 0 575 FILE *fp; 576 fp = fopen("/var/log/commit_ret", "w"); 577 fclose(fp); 578#endif 579 char cmd[]="nvram commit"; 580 system(cmd); 581 return 1; 582} 583int nvram_get_file(const char *key, const char *fname, int max) 584{ 585 int n; 586 char *p; 587 char *b; 588 int r; 589 590 r = 0; 591 p = nvram_safe_get(key); 592 n = strlen(p); 593 if (n <= max) { 594 if ((b = malloc(base64_decoded_len(n) + 128)) != NULL) { 595 n = base64_decode_t(p, b, n); 596 if (n > 0) r = (f_write(fname, b, n, 0, 0644) == n); 597 free(b); 598 } 599 } 600 return r; 601} 602 603int nvram_set_file(const char *key, const char *fname, int max) 604{ 605 char *in; 606 char *out; 607 long len; 608 int n; 609 int r; 610 611 if ((len = f_size(fname)) > max) return 0; 612 max = (int)len; 613 r = 0; 614 if (f_read_alloc(fname, &in, max) == max) { 615 if ((out = malloc(base64_encoded_len(max) + 128)) != NULL) { 616 n = base64_encode(in, out, max); 617 out[n] = 0; 618 nvram_set(key, out); 619 free(out); 620 r = 1; 621 } 622 free(in); 623 } 624 return r; 625} 626void start_ssl() 627{ 628 fprintf(stderr,"\nstart ssl\n"); 629 int ok; 630 int save; 631 int retry; 632 unsigned long long sn; 633 char t[32]; 634 635 retry = 1; 636 while (retry) { 637 char *https_crt_save = nvram_get("https_crt_save"); 638 if(https_crt_save != NULL) 639 { 640 if(atoi(https_crt_save) == 1) 641 save = 1; //pem nvram is exit 642 else 643 save = 0; 644 } 645 else 646 save = 0; 647 free(https_crt_save); 648 //save = nvram_match("https_crt_save", "1"); 649 650 if (1) { 651 ok = 0; 652 if (save) { 653 fprintf(stderr, "Save SSL certificate...\n"); // tmp test 654 if (nvram_get_file("https_crt_file", "/tmp/cert.tgz", 8192)) { 655 system("tar -xzf /tmp/cert.tgz -C / etc/cert.pem etc/key.pem"); 656 usleep(1000*100); 657 system("cat /etc/key.pem /etc/cert.pem > /etc/server.pem"); 658 ok = 1; 659 unlink("/tmp/cert.tgz"); 660 } 661 } 662 if (!ok) { 663 fprintf(stderr, "Generating SSL certificate...\n"); // tmp test 664 // browsers seems to like this when the ip address moves... -- zzz 665 f_read("/dev/urandom", &sn, sizeof(sn)); 666 667 sprintf(t, "%llu", sn & 0x7FFFFFFFFFFFFFFFULL); 668 char *cmd_app=NULL; 669 cmd_app=(char *)malloc(sizeof(char)*(strlen(t)+64)); 670 memset(cmd_app,'\0',sizeof(cmd_app)); 671 sprintf(cmd_app,"%s %s","/opt/etc/apps_asus_script/gencert.sh",t); 672 system(cmd_app); 673 while(-1==access("/etc/cert.pem",F_OK)||-1==access("/etc/key.pem",F_OK)) 674 { 675 usleep(1000*100); 676 } 677 free(cmd_app); 678 679 system("tar -C / -czf /tmp/cert.tgz etc/cert.pem etc/key.pem"); 680 while(-1==access("/tmp/cert.tgz",F_OK)) 681 { 682 usleep(1000*100); 683 } 684 685 save = 1; 686 } 687 } 688 fprintf(stderr,"\n nvram get https_crt_file\n"); 689 if ((save) && (*nvram_safe_get("https_crt_file")) == 0) { 690 691 if (nvram_setfile_https_crt_file("/tmp/cert.tgz", 8192)) { 692 Cdbg(DBE, "complete nvram_setfile_https_crt_file"); 693 nvram_set_https_crt_save("1"); 694 nvram_do_commit(); 695 Cdbg(DBE, "end nvram_setfile_https_crt_file"); 696 } 697 698 unlink("/tmp/cert.tgz"); 699 } 700 fprintf(stderr,"\n over ssl \n"); 701 retry = 0; 702 } 703} 704#elif defined USE_TCAPI 705 706#else 707extern char *nvram_get(const char *name); 708extern int nvram_set(const char *name, const char *value); 709extern int nvram_commit(void); 710#endif 711 712int nvram_smbdav_pc_append(const char* ap_str) 713{ 714#ifdef USE_TCAPI 715 char nv_var_val[MAXLEN_TCAPI_MSG] = {0}; 716 if( tcapi_get(WEBDAV, WEBDAV_SMB_PC, nv_var_val) ){ 717 return -1; 718 } 719 char tmp_nv_var_val[120]={0}; 720 strcpy(tmp_nv_var_val, nv_var_val); 721 strcat(tmp_nv_var_val, ap_str); 722 tcapi_set(WEBDAV, WEBDAV_SMB_PC, tmp_nv_var_val); 723#else 724 char* nv_var_val=NULL; 725 if( !( nv_var_val = nvram_get(WEBDAV_SMB_PC)) ){ 726 return -1; 727 } 728 char tmp_nv_var_val[120]={0}; 729 strcpy(tmp_nv_var_val, nv_var_val); 730 strcat(tmp_nv_var_val, ap_str); 731#ifdef APP_IPKG 732 free(nv_var_val); 733#endif 734 nvram_set(WEBDAV_SMB_PC, tmp_nv_var_val); 735#endif 736 737 return 0; 738} 739 740char* nvram_get_smbdav_str(void) 741{ 742#ifdef USE_TCAPI 743 static char smbdav_str[MAXLEN_TCAPI_MSG] = {0}; 744 tcapi_get(WEBDAV, WEBDAV_SMB_PC, smbdav_str); 745 return smbdav_str; 746#else 747 return nvram_get(WEBDAV_SMB_PC); 748#endif 749} 750 751int nvram_set_smbdav_str(const char* pc_info) 752{ 753#ifdef USE_TCAPI 754 return tcapi_set(WEBDAV, WEBDAV_SMB_PC, pc_info); 755#else 756 return nvram_set(WEBDAV_SMB_PC, pc_info); 757#endif 758} 759 760char* nvram_get_sharelink_str(void) 761{ 762#ifdef USE_TCAPI 763 static char sharelink_str[MAXLEN_TCAPI_MSG] = {0}; 764 tcapi_get(WEBDAV, SHARELINK, sharelink_str); 765 return sharelink_str; 766#else 767 return nvram_get(SHARELINK); 768#endif 769} 770 771int nvram_set_sharelink_str(const char* share_info) 772{ 773#ifdef USE_TCAPI 774 if(strlen(share_info)>576) 775 return 0; 776 return tcapi_set(WEBDAV, SHARELINK, share_info); 777#else 778 return nvram_set(SHARELINK, share_info); 779#endif 780} 781 782int nvram_do_commit(void){ 783#ifdef USE_TCAPI 784 tcapi_commit(WEBDAV); 785#else 786 nvram_commit(); 787#endif 788 return 1; 789} 790 791int nvram_is_ddns_enable(void) 792{ 793#ifdef USE_TCAPI 794 char ddns_e[4] = {0}; 795 int ddns_enable_x=0; 796 if( tcapi_get(DDNS, DDNS_ENANBLE_X, ddns_e) ) { 797 ddns_enable_x = atoi(ddns_e); 798 //Cdbg(DBE," ddns_e = %s", ddns_e); 799 } 800 if(ddns_enable_x) 801 return 1; 802 else 803 return 0; 804#else 805 char* ddns_e = NULL; 806 int ddns_enable_x = 0; 807 if( (ddns_e = nvram_get(DDNS_ENANBLE_X))!=NULL ){ 808 ddns_enable_x = atoi(ddns_e); 809 //Cdbg(DBE," ddns_e = %s", ddns_e); 810 #ifdef APP_IPKG 811 free(ddns_e); 812 #endif 813 } 814 if(ddns_enable_x) return 1; 815 else return 0; 816#endif 817} 818 819char* nvram_get_ddns_server_name(void) 820{ 821#ifdef USE_TCAPI 822 static char ddns_server_name[64] = {0}; 823 tcapi_get(DDNS, DDNS_SERVER_X, ddns_server_name); 824 return ddns_server_name; 825#else 826 return nvram_get(DDNS_SERVER_X); 827#endif 828} 829 830char* nvram_get_ddns_host_name(void) 831{ 832#ifdef USE_TCAPI 833 static char ddns_host_name_x[MAXLEN_TCAPI_MSG] = {0}; 834 if(tcapi_get(DDNS, DDNS_HOST_NAME_X, ddns_host_name_x)) { 835 //Cdbg(DBE,"ddns_hostname_x = %s", ddns_host_name_x); 836 return NULL; 837 } 838 else 839 return ddns_host_name_x; 840#else 841 842 /* 843 nvram get/set ddns_enable_x 844 nvram get/set ddns_server_x (WWW.ASUS.COM) 845 nvram get/set ddns_hostname_x (RT-N66U-00E012112233.asuscomm.com) 846 rc rc_service restart_ddns or notify_rc(?�restart_ddns?? through libshared 847 */ 848 char* ddns_host_name_x=NULL; 849 if(!nvram_is_ddns_enable()) 850 goto nvram_get_ddns_host_name_EXIT; 851 if(!nvram_get_ddns_server_name()) 852 goto nvram_get_ddns_host_name_EXIT; 853 ddns_host_name_x= nvram_get (DDNS_HOST_NAME_X); 854 855nvram_get_ddns_host_name_EXIT: 856 //Cdbg(DBE,"ddns_hostname_x = %s", ddns_host_name_x); 857 return ddns_host_name_x; 858#endif 859} 860 861char* nvram_get_ddns_host_name2(void) 862{ 863#ifdef USE_TCAPI 864 static char ddns_host_name_x[MAXLEN_TCAPI_MSG] = {0}; 865 tcapi_get(DDNS, DDNS_HOST_NAME_X, ddns_host_name_x); 866 return ddns_host_name_x; 867#else 868 char* ddns_host_name_x = NULL; 869 ddns_host_name_x = nvram_get(DDNS_HOST_NAME_X); 870 return ddns_host_name_x; 871#endif 872} 873 874char* nvram_get_productid(void) 875{ 876 return get_productid(); 877} 878 879char* nvram_get_acc_list(void) 880{ 881#ifdef USE_TCAPI 882 static char acc_list[MAXLEN_TCAPI_MSG] = {0}; 883 tcapi_get(SAMBA, ACC_LIST, acc_list); 884 return acc_list; 885#else 886 return nvram_get(ACC_LIST); 887#endif 888} 889 890char* nvram_get_aicloud_acc_list(void) 891{ 892#ifdef USE_TCAPI 893 static char aicloud_acc_list[MAXLEN_TCAPI_MSG] = {0}; 894 tcapi_get(WEBDAV, AICLOUD_ACC_LIST, aicloud_acc_list); 895 return aicloud_acc_list; 896#else 897 return nvram_get(AICLOUD_ACC_LIST); 898#endif 899} 900 901int nvram_set_aicloud_acc_list(const char* aicloud_acc_list) 902{ 903#ifdef USE_TCAPI 904 return tcapi_set(WEBDAV, AICLOUD_ACC_LIST, aicloud_acc_list); 905#else 906 return nvram_set(AICLOUD_ACC_LIST, aicloud_acc_list); 907#endif 908} 909 910char* nvram_get_aicloud_acc_invite_list(void) 911{ 912#ifdef USE_TCAPI 913 static char aicloud_acc_invite_list[MAXLEN_TCAPI_MSG] = {0}; 914 tcapi_get(WEBDAV, AICLOUD_ACC_INVITE_LIST, aicloud_acc_invite_list); 915 return aicloud_acc_invite_list; 916#else 917 return nvram_get(AICLOUD_ACC_INVITE_LIST); 918#endif 919} 920 921int nvram_set_aicloud_acc_invite_list(const char* aicloud_acc_invite_list) 922{ 923#ifdef USE_TCAPI 924 return tcapi_set(WEBDAV, AICLOUD_ACC_INVITE_LIST, aicloud_acc_invite_list); 925#else 926 return nvram_set(AICLOUD_ACC_INVITE_LIST, aicloud_acc_invite_list); 927#endif 928} 929 930char* nvram_get_webdavaidisk(void) 931{ 932#ifdef USE_TCAPI 933 static char webdavaidisk[4] = {0}; 934 tcapi_get(WEBDAV, WEBDAVAIDISK, webdavaidisk); 935 return webdavaidisk; 936#else 937 return nvram_get(WEBDAVAIDISK); 938#endif 939} 940 941int nvram_set_webdavaidisk(const char* enable) 942{ 943#ifdef USE_TCAPI 944 tcapi_set(WEBDAV, WEBDAVAIDISK, enable); 945#else 946 nvram_set(WEBDAVAIDISK, enable); 947#endif 948 return 1; 949} 950 951char* nvram_get_webdavproxy(void) 952{ 953#ifdef USE_TCAPI 954 static char webdavproxy[4] = {0}; 955 tcapi_get(WEBDAV, WEBDAVPROXY, webdavproxy); 956 return webdavproxy; 957#else 958 return nvram_get(WEBDAVPROXY); 959#endif 960} 961 962int nvram_set_webdavproxy(const char* enable) 963{ 964#ifdef USE_TCAPI 965 tcapi_set(WEBDAV, WEBDAVPROXY, enable); 966#else 967 nvram_set(WEBDAVPROXY, enable); 968#endif 969 return 1; 970} 971 972char* nvram_get_acc_webdavproxy(void) 973{ 974#ifdef USE_TCAPI 975 static char acc_webdavproxy[MAXLEN_TCAPI_MSG] = {0}; 976 tcapi_get(WEBDAV, ACC_WEBDAVPROXY, acc_webdavproxy); 977 return acc_webdavproxy; 978#else 979 return nvram_get(ACC_WEBDAVPROXY); 980#endif 981} 982 983int nvram_get_st_samba_mode(void) 984{ 985#ifdef USE_TCAPI 986 char st_samba_mode[4] ={0}; 987 int a = 0; 988 tcapi_get(SAMBA, ST_SAMBA_FORCE_MODE, st_samba_mode); 989 990 if(strcmp(st_samba_mode,"")==0) 991 tcapi_get(SAMBA, ST_SAMBA_MODE, st_samba_mode); 992 993 a = atoi(st_samba_mode); 994 return a; 995#else 996 char* res = nvram_get(ST_SAMBA_FORCE_MODE); 997 998 if(res==NULL) 999 res = nvram_get(ST_SAMBA_MODE); 1000 1001 int a = atoi(res); 1002#ifdef APP_IPKG 1003 free(res); 1004#endif 1005 return a; 1006#endif 1007} 1008 1009char* nvram_get_http_username(void) 1010{ 1011#ifdef USE_TCAPI 1012 static char http_username[32] = {0}; 1013 tcapi_get(ACCOUNT, HTTP_USERNAME, http_username); 1014 return http_username; 1015#else 1016 return nvram_get(HTTP_USERNAME); 1017#endif 1018} 1019 1020char* nvram_get_http_passwd(void) 1021{ 1022#ifdef USE_TCAPI 1023 static char http_passwd[32] = {0}; 1024 tcapi_get(ACCOUNT, HTTP_PASSWD, http_passwd); 1025 return http_passwd; 1026#else 1027 return nvram_get(HTTP_PASSWD); 1028#endif 1029} 1030 1031char* nvram_get_computer_name(void) 1032{ 1033#ifdef USE_TCAPI 1034 static char computer_name[16] = {0}; 1035 tcapi_get(SAMBA, COMPUTER_NAME, computer_name); 1036 return computer_name; 1037#else 1038 return nvram_get(COMPUTER_NAME); 1039#endif 1040} 1041 1042char* nvram_get_router_mac(void) 1043{ 1044#ifdef USE_TCAPI 1045 static char router_mac[32] = {0}; 1046 tcapi_get(INFOETH, ETHMACADDR, router_mac); 1047 return router_mac; 1048#else 1049 char* mac = nvram_get(ETHMACADDR); 1050 return mac; 1051#endif 1052} 1053 1054char* nvram_get_firmware_version(void) 1055{ 1056#ifdef USE_TCAPI 1057 static char firmware_version[16] = {0}; 1058 tcapi_get(DEVICEINFO, FIRMVER, firmware_version); 1059 return firmware_version; 1060#else 1061 return nvram_get(FIRMVER); 1062#endif 1063} 1064 1065char* nvram_get_build_no(void) 1066{ 1067#ifdef USE_TCAPI 1068 return 0; 1069#else 1070 return nvram_get(BUILDNO); 1071#endif 1072} 1073 1074char* nvram_get_st_webdav_mode(void) 1075{ 1076#ifdef USE_TCAPI 1077 static char st_webdav_mode[4] = {0}; 1078 tcapi_get(WEBDAV, ST_WEBDAV_MODE, st_webdav_mode); 1079 return st_webdav_mode; 1080#else 1081 return nvram_get(ST_WEBDAV_MODE); 1082#endif 1083} 1084 1085char* nvram_get_webdav_http_port(void) 1086{ 1087#ifdef USE_TCAPI 1088 static char webdav_http_port[8] = {0}; 1089 tcapi_get(WEBDAV, WEBDAV_HTTP_PORT, webdav_http_port); 1090 return webdav_http_port; 1091#else 1092 return nvram_get(WEBDAV_HTTP_PORT); 1093#endif 1094} 1095 1096char* nvram_get_webdav_https_port(void) 1097{ 1098#ifdef USE_TCAPI 1099 static char webdav_https_port[8] = {0}; 1100 tcapi_get(WEBDAV, WEBDAV_HTTPS_PORT, webdav_https_port); 1101 return webdav_https_port; 1102#else 1103 return nvram_get(WEBDAV_HTTPS_PORT); 1104#endif 1105} 1106 1107char* nvram_get_http_enable(void) 1108{ 1109 // 0 --> http 1110 // 1 --> https 1111 // 2 --> both 1112#ifdef USE_TCAPI 1113 return 0; 1114#else 1115 return nvram_get(HTTP_ENABLE); 1116#endif 1117} 1118 1119char* nvram_get_lan_https_port(void){ 1120#ifdef USE_TCAPI 1121 return 0; 1122#else 1123 return nvram_get(LAN_HTTPS_PORT); 1124#endif 1125} 1126 1127char* nvram_get_misc_http_x(void) 1128{ 1129#ifdef USE_TCAPI 1130 static char misc_http_x[4] = {0}; 1131 tcapi_get(FIREWALL, MISC_HTTP_X, misc_http_x); 1132 return misc_http_x; 1133#else 1134 return nvram_get(MISC_HTTP_X); 1135#endif 1136} 1137 1138char* nvram_get_misc_http_port(void) 1139{ 1140#ifdef USE_TCAPI 1141 static char misc_http_port[8] = {0}; 1142 tcapi_get(FIREWALL, MISC_HTTP_PORT, misc_http_port); 1143 return misc_http_port; 1144#else 1145 return nvram_get(MISC_HTTP_PORT); 1146#endif 1147} 1148 1149char* nvram_get_misc_https_port(void) 1150{ 1151#ifdef USE_TCAPI 1152 static char misc_https_port[8] = {0}; 1153 tcapi_get(FIREWALL, MISC_HTTPS_PORT, misc_https_port); 1154 return misc_https_port; 1155#else 1156 return nvram_get(MISC_HTTPS_PORT); 1157#endif 1158} 1159 1160char* nvram_get_enable_webdav_captcha(void) 1161{ 1162#ifdef USE_TCAPI 1163 static char enable_webdav_captcha[4] = {0}; 1164 tcapi_get(WEBDAV, ENABLE_WEBDAV_CAPTCHA, enable_webdav_captcha); 1165 return enable_webdav_captcha; 1166#else 1167 return nvram_get(ENABLE_WEBDAV_CAPTCHA); 1168#endif 1169} 1170 1171char* nvram_get_enable_webdav_lock(void) 1172{ 1173#ifdef USE_TCAPI 1174 static char enable_webdav_lock[4] = {0}; 1175 tcapi_get(WEBDAV, ENABLE_WEBDAV_LOCK, enable_webdav_lock); 1176 return enable_webdav_lock; 1177#else 1178 return nvram_get(ENABLE_WEBDAV_LOCK); 1179#endif 1180} 1181 1182char* nvram_get_webdav_acc_lock(void) 1183{ 1184#ifdef USE_TCAPI 1185 static char webdav_acc_lock[4] = {0}; 1186 tcapi_get(WEBDAV, WEBDAV_ACC_LOCK, webdav_acc_lock); 1187 return webdav_acc_lock; 1188#else 1189 return nvram_get(WEBDAV_ACC_LOCK); 1190#endif 1191} 1192 1193int nvram_set_webdav_acc_lock(const char* acc_lock) 1194{ 1195#ifdef USE_TCAPI 1196 tcapi_set(WEBDAV, WEBDAV_ACC_LOCK, acc_lock); 1197#else 1198 nvram_set(WEBDAV_ACC_LOCK, acc_lock); 1199#endif 1200 return 1; 1201} 1202 1203char* nvram_get_webdav_lock_interval(void) 1204{ 1205#ifdef USE_TCAPI 1206 static char webdav_lock_interval[4] = {0}; 1207 tcapi_get(WEBDAV, WEBDAV_LOCK_INTERVAL, webdav_lock_interval); 1208 return webdav_lock_interval; 1209#else 1210 return nvram_get(WEBDAV_LOCK_INTERVAL); 1211#endif 1212} 1213 1214char* nvram_get_webdav_lock_times(void) 1215{ 1216#ifdef USE_TCAPI 1217 static char webdav_lock_times[4] = {0}; 1218 tcapi_get(WEBDAV, WEBDAV_LOCK_TIMES, webdav_lock_times); 1219 return webdav_lock_times; 1220#else 1221 return nvram_get(WEBDAV_LOCK_TIMES); 1222#endif 1223} 1224 1225char* nvram_get_webdav_last_login_info(void) 1226{ 1227#ifdef USE_TCAPI 1228 static char webdav_last_login_info[MAXLEN_TCAPI_MSG] = {0}; 1229 tcapi_get(WEBDAV, WEBDAV_LAST_LOGININFO, webdav_last_login_info); 1230 return webdav_last_login_info; 1231#else 1232 return nvram_get(WEBDAV_LAST_LOGININFO); 1233#endif 1234} 1235 1236int nvram_set_webdav_last_login_info(const char* last_login_info) 1237{ 1238#ifdef USE_TCAPI 1239 return tcapi_set(WEBDAV, WEBDAV_LAST_LOGININFO, last_login_info); 1240#else 1241 return nvram_set(WEBDAV_LAST_LOGININFO, last_login_info); 1242#endif 1243} 1244 1245char* nvram_get_latest_version(void) 1246{ 1247#ifdef USE_TCAPI 1248 static char latest_version[16] = {0}; 1249 tcapi_get(WEBDAV, WEBS_STATE_INFO, latest_version); 1250 return latest_version; 1251#else 1252 return nvram_get(WEBS_STATE_INFO); 1253#endif 1254} 1255 1256int nvram_get_webs_state_error(void) 1257{ 1258#ifdef USE_TCAPI 1259 char webs_state_error[4] = {0}; 1260 int a = 0; 1261 tcapi_get(WEBDAV, WEBS_STATE_ERROR, webs_state_error); 1262 a = atoi(webs_state_error); 1263 return a; 1264#else 1265 char* res = nvram_get(WEBS_STATE_ERROR); 1266 int a = atoi(res); 1267#ifdef APP_IPKG 1268 free(res); 1269#endif 1270 return a; 1271#endif 1272} 1273 1274char* nvram_get_apps_sq(void) 1275{ 1276#ifdef USE_TCAPI 1277 char apps_sq[2] = {0}; 1278 tcapi_get(APPS, APPS_SQ, apps_sq); 1279 return apps_sq; 1280#else 1281 return 0; 1282#endif 1283} 1284 1285char* nvram_get_share_link_param(void) 1286{ 1287#ifdef USE_TCAPI 1288 static char share_link_param[MAXLEN_TCAPI_MSG] = {0}; 1289 tcapi_get(WEBDAV, SHARE_LINK_PARAM, share_link_param); 1290 return share_link_param; 1291#else 1292 return nvram_get(SHARE_LINK_PARAM); 1293#endif 1294} 1295 1296char* nvram_get_time_zone(void) 1297{ 1298#ifdef USE_TCAPI 1299 static char time_zone[MAXLEN_TCAPI_MSG] = {0}; 1300 tcapi_get(TIMEZONE, TIME_ZONE_X, time_zone); 1301 return time_zone; 1302#else 1303 return nvram_get(TIME_ZONE_X); 1304#endif 1305} 1306 1307 1308int nvram_set_share_link_result(const char* result) 1309{ 1310#ifdef USE_TCAPI 1311 tcapi_set(WEBDAV, SHARE_LINK_RESULT, result); 1312#else 1313 nvram_set(SHARE_LINK_RESULT, result); 1314#endif 1315 return 1; 1316} 1317 1318int nvram_wan_primary_ifunit(void) 1319{ 1320#ifdef USE_TCAPI 1321 char tmp[4], prefix[16] = {0}; 1322 int unit; 1323 for (unit = 0; unit < 12; unit ++) { 1324 if( unit > 0 && unit < 8 ) //ignore nas1~7 which should be bridge mode for ADSL 1325 continue; 1326 snprintf(prefix, sizeof(prefix), "Wan_PVC%d", unit); 1327 tcapi_get(prefix, "Active", tmp); 1328 if (!strcmp(tmp, "Yes")) 1329 return unit; 1330 } 1331#else 1332 int unit; 1333 for (unit = 0; unit < 10; unit ++) { 1334 char tmp[100], prefix[] = "wanXXXXXXXXXX_"; 1335 snprintf(prefix, sizeof(prefix), "wan%d_", unit); 1336 char* res = strcat_r(prefix, "primary", tmp); 1337 if (strncmp(res, "1", 1)==0) 1338 return unit; 1339 } 1340#endif 1341 return 0; 1342} 1343 1344char* nvram_get_wan_ip(void) 1345{ 1346#ifdef USE_TCAPI 1347 static char wan_ip[16]= {0}; 1348 char prefix[32] = {0}; 1349 int unit = nvram_wan_primary_ifunit(); 1350 snprintf(prefix, sizeof(prefix), "%s_PVC%d", DEVICEINFO, unit); 1351 tcapi_get(prefix, "WanIP", wan_ip); 1352 return wan_ip; 1353#else 1354 char *wan_ip; 1355 char tmp[32], prefix[] = "wanXXXXXXXXXX_"; 1356 int unit = nvram_wan_primary_ifunit(); 1357 snprintf(prefix, sizeof(prefix), "wan%d_", unit); 1358 wan_ip = nvram_get(strcat_r(prefix, "ipaddr", tmp)); 1359 return wan_ip; 1360#endif 1361} 1362 1363char* nvram_get_swpjverno(void) 1364{ 1365#ifdef USE_TCAPI 1366 static char swpjverno[MAXLEN_TCAPI_MSG] = {0}; 1367 tcapi_get(WEBDAV, SWPJVERNO, swpjverno); 1368 return swpjverno; 1369#else 1370 return nvram_get(SWPJVERNO); 1371#endif 1372} 1373 1374char* nvram_get_extendno(void) 1375{ 1376#ifdef USE_TCAPI 1377 static char extendno[MAXLEN_TCAPI_MSG] = {0}; 1378 tcapi_get(WEBDAV, EXTENDNO, extendno); 1379 return extendno; 1380#else 1381 return nvram_get(EXTENDNO); 1382#endif 1383} 1384 1385char* nvram_get_dms_enable(void) 1386{ 1387 // 0 --> off 1388 // 1 --> on 1389#ifdef USE_TCAPI 1390 static char dms_enable[MAXLEN_TCAPI_MSG] = {0}; 1391 tcapi_get(WEBDAV, DMS_ENABLE, dms_enable); 1392 return dms_enable; 1393#else 1394 return nvram_get(DMS_ENABLE); 1395#endif 1396} 1397 1398char* nvram_get_dms_dbcwd(void) 1399{ 1400#ifdef USE_TCAPI 1401 /* 1402 static char dms_dbcwd[MAXLEN_TCAPI_MSG] = {0}; 1403 tcapi_get(APPS, MS_PATH, dms_dbcwd); 1404 strcat(dms_dbcwd, "/minidlna"); 1405 return dms_dbcwd; 1406 */ 1407 return NULL; 1408#else 1409 return nvram_get(DMS_DBCWD); 1410#endif 1411} 1412 1413char* nvram_get_dms_dir(void) 1414{ 1415#ifdef USE_TCAPI 1416 /* 1417 static char dms_dir[MAXLEN_TCAPI_MSG] = {0}; 1418 tcapi_get(APPS, MS_PATH, dms_dir); 1419 return dms_dir; 1420 */ 1421 return NULL; 1422#else 1423 return nvram_get(DMS_DIR); 1424#endif 1425} 1426 1427char* nvram_get_ms_enable(void) 1428{ 1429#if EMBEDDED_EANBLE 1430 1431#ifdef USE_TCAPI 1432 static char ms_enable[MAXLEN_TCAPI_MSG] = {0}; 1433 tcapi_get(APPS, MS_DLNA, ms_enable); 1434 return ms_enable; 1435#else 1436 return nvram_get(MS_DLNA); 1437#endif 1438 1439#else 1440 return "1"; 1441#endif 1442} 1443 1444int nvram_set_https_crt_cn(const char* cn) 1445{ 1446#ifdef USE_TCAPI 1447 tcapi_set(WEBDAV, HTTPS_CRT_CN, cn); 1448#else 1449 nvram_set(HTTPS_CRT_CN, cn); 1450#endif 1451 return 1; 1452} 1453 1454char* nvram_get_https_crt_cn(){ 1455#ifdef USE_TCAPI 1456 static char https_crt_cn[MAXLEN_TCAPI_MSG] = {0}; 1457 tcapi_get(WEBDAV, HTTPS_CRT_CN, https_crt_cn); 1458 return https_crt_cn; 1459#else 1460 return nvram_get(HTTPS_CRT_CN); 1461#endif 1462} 1463 1464int nvram_setfile_https_crt_file(const char* file, int size) 1465{ 1466#ifdef USE_TCAPI 1467 1468#else 1469 nvram_set_file(HTTPS_CRT_FILE, file, size); 1470#endif 1471 return 1; 1472} 1473 1474int nvram_getfile_https_crt_file(const char* file, int size) 1475{ 1476#ifdef USE_TCAPI 1477 1478#else 1479 nvram_get_file(HTTPS_CRT_FILE, file, size); 1480#endif 1481 return 1; 1482} 1483 1484char* nvram_get_https_crt_file() 1485{ 1486#ifdef USE_TCAPI 1487 1488#else 1489 return nvram_get("https_crt_file"); 1490#endif 1491} 1492 1493char* nvram_get_odmpid() 1494{ 1495#ifdef USE_TCAPI 1496 return NULL; 1497#else 1498 return nvram_get(ODMPID); 1499#endif 1500} 1501 1502int nvram_set_https_crt_save(const char* enable) 1503{ 1504#ifdef USE_TCAPI 1505 1506#else 1507 nvram_set(HTTPS_CRT_SAVE, enable); 1508#endif 1509 return 1; 1510} 1511 1512int nvram_set_value(const char* key, const char* value){ 1513#ifdef USE_TCAPI 1514 1515#else 1516 nvram_set(key, value); 1517#endif 1518 return 1; 1519} 1520 1521char* nvram_get_value(const char* key){ 1522#ifdef USE_TCAPI 1523 static char value[MAXLEN_TCAPI_MSG] = {0}; 1524 1525 if(!strcmp(key, "webs_state_update")) { 1526 tcapi_get("WebCustom_Entry", "webs_state_update", value); 1527 } 1528 else if(!strcmp(key, "webs_state_error")) { 1529 tcapi_get("WebCustom_Entry", "webs_state_error", value); 1530 } 1531 else if(!strcmp(key, "webs_state_upgrade")) { 1532 tcapi_get("WebCustom_Entry", "webs_state_upgrade", value); 1533 } 1534 1535 return value; 1536#else 1537 return nvram_get(key); 1538#endif 1539} 1540 1541#endif 1542