开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
win32.c
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：16k
源码类别：

通讯编程

开发平台：

Visual C++

win32.c：源码内容
  1. /*
  2.  * Copyright (c) 1996 The Regents of the University of California.
  3.  * All rights reserved.
  4.  * 
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *  This product includes software developed by the Network Research
  16.  *  Group at Lawrence Berkeley National Laboratory.
  17.  * 4. Neither the name of the University nor of the Laboratory may be used
  18.  *    to endorse or promote products derived from this software without
  19.  *    specific prior written permission.
  20.  * 
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  * This module contributed by John Brezak <brezak@apollo.hp.com>.
  34.  * January 31, 1996
  35.  *
  36.  * @(#) $Header: /cvsroot/nsnam/ns-2/common/win32.c,v 1.6 2006/02/21 15:20:18 mahrenho Exp $ (LBL)
  37.  */
  39. #ifdef WIN32
  41. #include <assert.h>
  42. #include <io.h>
  43. #include <process.h>
  44. #include <fcntl.h>
  45. #include <windows.h>
  46. #include <malloc.h>
  47. #include <string.h>
  48. #include <stdio.h>
  49. #include <time.h>
  50. #include <winsock.h>
  51. #include <tcl.h>
  52. #include "config.h"
  53. #include <locale.h>
  55. /* forward declarations */
  56. int WinGetUserName(ClientData, Tcl_Interp*, int ac, char**av);
  57. int WinGetHostName(ClientData, Tcl_Interp*, int ac, char**av);
  58. int WinPutRegistry(ClientData, Tcl_Interp*, int ac, char**av);
  59. int WinGetRegistry(ClientData, Tcl_Interp*, int ac, char**av);
  60. void TkConsoleCreate();
  61. int TkConsoleInit(Tcl_Interp* interp);
  62.         
  63. int
  64. uname(struct utsname *ub)
  65. {
  66.     char *ptr;
  67.     DWORD version;
  68.     SYSTEM_INFO sysinfo;
  69.     char hostname[4096];
  70.     
  71.     version = GetVersion();
  72.     GetSystemInfo(&sysinfo);
  73.     
  74.     switch (sysinfo.wProcessorArchitecture) {
  75.     case PROCESSOR_ARCHITECTURE_INTEL:
  76. (void)strcpy(ub->machine, "ix86");
  77. break;
  78.     case PROCESSOR_ARCHITECTURE_MIPS :
  79. (void)strcpy(ub->machine, "mips");
  80. break;
  81.     case PROCESSOR_ARCHITECTURE_ALPHA:
  82. (void)strcpy(ub->machine, "alpha");
  83. break;
  84.     case PROCESSOR_ARCHITECTURE_PPC:
  85. (void)strcpy(ub->machine, "ppc");
  86. break;
  87.     default:
  88. (void)strcpy(ub->machine, "unknown");
  89. break;
  90.     }
  91.     
  92.     if (version < 0x80000000) {
  93. (void)strcpy(ub->version, "NT");
  94.     }
  95.     else if (LOBYTE(LOWORD(version))<4) {
  96. (void)strcpy(ub->version, "Win32s");
  97.     }
  98.     else /* Win95 */ {
  99. (void)strcpy(ub->version, "Win95");
  100.     }
  101.     (void)sprintf(ub->release, "%u.%u",
  102.   (DWORD)(LOBYTE(LOWORD(version))),
  103.   (DWORD)(HIBYTE(LOWORD(version))));
  104.     (void)strcpy(ub->sysname, "Windows");
  105.     if (gethostname(hostname, sizeof(hostname)) == 0) {
  106. if (ptr = strchr(hostname, '.'))
  107.     *ptr = '';
  108.     }
  109.     else {
  110. perror("uname: gethostname failed");
  111. strcpy(hostname, "FAILURE");
  112.     }
  113.     strncpy(ub->nodename, hostname, sizeof(ub->nodename));
  114.     ub->nodename[_SYS_NMLN - 1] = '';
  115.     return 0;
  116. }
  118. int strcasecmp(const char *s1, const char *s2)
  119. {
  120.     return stricmp(s1, s2);
  121. }
  123. uid_t getuid(void) 
  124. { 
  125.     return 1;
  126.     
  127. }
  129. gid_t getgid(void)
  130. {
  131.     return 0;
  132. }
  134. int gethostid(void)
  135. {
  136.     /*XXX*/
  137.     return 0;
  138. }
  140. __inline int nice(int pri)
  141. {
  142.     return 0;
  143. }
  145. extern void TkWinXInit(HINSTANCE hInstance);
  146. extern int main(int argc, const char *argv[]);
  147. extern int __argc;
  148. extern char **__argv;
  150. static char argv0[255]; /* Buffer used to hold argv0. */
  152. char *__progname = "mash";
  154. void
  155. ShowMessage(int level, char *msg)
  156. {
  157.     MessageBeep(level);
  158.     MessageBox(NULL, msg, __progname,
  159.        level | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
  160. }
  162. int SetupConsole()
  163. {
  164.     /*
  165.      * stuff from knowledge base Q105305 (see that for details)
  166.      * open a console and do the work around to get the console to work in all
  167.      * cases
  168.      */
  169.     int hCrt;
  170.     FILE *hf=0;
  171.     const COORD screenSz = {80, 5000}; /* size of console buffer */
  173.     AllocConsole();
  175.     hf=0;
  176.     hCrt = _open_osfhandle(
  177.             (long)GetStdHandle(STD_OUTPUT_HANDLE), _O_TEXT);
  178.     if (hCrt!=-1) hf = _fdopen(hCrt, "w");
  179.     if (hf!=0) *stdout = *hf;
  180.     if (hCrt==-1 || hf==0 || 0!=setvbuf(stdout, NULL, _IONBF, 0)) {
  181.             ShowMessage(MB_ICONINFORMATION,
  182.                         "unable to mount reroute stdout");
  183.             return FALSE;
  184.     }
  185.     SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), screenSz);
  187.     hf=0;
  188.     hCrt = _open_osfhandle(
  189.         (long)GetStdHandle(STD_ERROR_HANDLE), _O_TEXT);
  190.     if (hCrt!=-1) hf = _fdopen(hCrt, "w");
  191.     if (hf!=0) *stderr = *hf;
  192.     if (hCrt==-1 || hf==0 || 0!=setvbuf(stderr, NULL, _IONBF, 0)) {
  193.             ShowMessage(MB_ICONINFORMATION,
  194.                         "reroute stderr failed in SetupConsole");
  195.             return FALSE;
  196.     }
  198.     hf=0;
  199.     hCrt = _open_osfhandle((long)GetStdHandle(STD_INPUT_HANDLE), _O_TEXT);
  200.     if (hCrt!=-1) hf = _fdopen(hCrt, "r");
  201.     if (hf!=0) *stdin = *hf;
  202.     if (hCrt==-1 || hf==0 || 0!=setvbuf(stdin, NULL, _IONBF, 0)) {
  203.             ShowMessage(MB_ICONINFORMATION,
  204.                         "reroute stdin failed in SetupConsole");
  205.             return FALSE;
  206.     }
  207.     return TRUE;
  208. }
  209.      
  211. int APIENTRY
  212. WinMain(
  213.     HINSTANCE hInstance,
  214.     HINSTANCE hPrevInstance,
  215.     LPSTR lpszCmdLine,
  216.     int nCmdShow)
  217. {
  218.     char *p;
  219.     WSADATA WSAdata;
  220.     int retcode;
  222.     setlocale(LC_ALL, "C");
  224.     /* XXX
  225.      * initialize our socket interface plus the tcl 7.5 socket
  226.      * interface (since they redefine some routines we call).
  227.      * eventually we should just call the tcl sockets but at
  228.      * the moment that's hard to set up since they only support
  229.      * tcp in the notifier.
  230.      */
  231.     if (WSAStartup(MAKEWORD (1, 1), &WSAdata)) {
  232.      perror("Windows Sockets init failed");
  233. abort();
  234.     }
  235. /*    TclHasSockets(NULL);
  237.     TkWinXInit(hInstance); */
  239.     /*
  240.      * Increase the application queue size from default value of 8.
  241.      * At the default value, cross application SendMessage of WM_KILLFOCUS
  242.      * will fail because the handler will not be able to do a PostMessage!
  243.      * This is only needed for Windows 3.x, since NT dynamically expands
  244.      * the queue.
  245.      */
  246.     SetMessageQueue(64);
  248.     GetModuleFileName(NULL, argv0, 255);
  249.     p = argv0;
  250.     __progname = strrchr(p, '/');
  251.     if (__progname != NULL) {
  252. __progname++;
  253.     }
  254.     else {
  255. __progname = strrchr(p, '\');
  256. if (__progname != NULL) {
  257.     __progname++;
  258. } else {
  259.     __progname = p;
  260. }
  261.     }
  263.     if (__argc>1) {            
  264.             SetupConsole();
  265.     }
  267.     retcode=main(__argc, (const char**)__argv);
  268.     if (retcode!=0) {
  269.             assert(FALSE);      /* don't die without letting user know why */
  270.     }
  271.     return retcode;
  272. }
  274. #if 0
  276. static char szTemp[4096];
  278. int
  279. printf(const char *fmt, ...)
  280. {
  281.     int retval;
  282.     
  283.     va_list ap;
  284.     va_start (ap, fmt);
  285.     retval = vsprintf(szTemp, fmt, ap);
  286.     OutputDebugString(szTemp);
  287.     ShowMessage(MB_ICONINFORMATION, szTemp);
  288.     va_end (ap);
  290.     return(retval);
  291. }
  293. int
  294. fprintf(FILE *f, const char *fmt, ...)
  295. {
  296.     int retval;
  297.     
  298.     va_list ap;
  299.     va_start (ap, fmt);
  300.     if (f == stderr) {
  301. retval = vsprintf(szTemp, fmt, ap);
  302. OutputDebugString(szTemp);
  303. ShowMessage(MB_ICONERROR, szTemp);
  304. va_end (ap);
  305.     }
  306.     else
  307. retval = vfprintf(f, fmt, ap);
  308.     
  309.     return(retval);
  310. }
  312. void
  313. perror(const char *msg)
  314. {
  315.     DWORD cMsgLen;
  316.     CHAR *msgBuf;
  317.     DWORD dwError = GetLastError();
  318.     
  319.     cMsgLen = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
  320.     FORMAT_MESSAGE_ALLOCATE_BUFFER | 40, NULL,
  321.     dwError,
  322.     MAKELANGID(0, SUBLANG_ENGLISH_US),
  323.     (LPTSTR) &msgBuf, 512,
  324.     NULL);
  325.     if (!cMsgLen)
  326. fprintf(stderr, "%s%sError code %lun",
  327. msg?msg:"", msg?": ":"", dwError);
  328.     else {
  329. fprintf(stderr, "%s%s%sn", msg?msg:"", msg?": ":"", msgBuf);
  330. LocalFree((HLOCAL)msgBuf);
  331.     }
  332. }
  334. int
  335. WinPutsCmd(clientData, interp, argc, argv)
  336.     ClientData clientData; /* ConsoleInfo pointer. */
  337.     Tcl_Interp *interp; /* Current interpreter. */
  338.     int argc; /* Number of arguments. */
  339.     char **argv; /* Argument strings. */
  340. {
  341.     int i, newline;
  342.     char *fileId;
  344.     i = 1;
  345.     newline = 1;
  346.     if ((argc >= 2) && (strcmp(argv[1], "-nonewline") == 0)) {
  347. newline = 0;
  348. i++;
  349.     }
  350.     if ((i < (argc-3)) || (i >= argc)) {
  351. Tcl_AppendResult(interp, "wrong # args: should be "", argv[0],
  352. " ?-nonewline? ?fileId? string"", (char *) NULL);
  353. return TCL_ERROR;
  354.     }
  356.     /*
  357.      * The code below provides backwards compatibility with an old
  358.      * form of the command that is no longer recommended or documented.
  359.      */
  361.     if (i == (argc-3)) {
  362. if (strncmp(argv[i+2], "nonewline", strlen(argv[i+2])) != 0) {
  363.     Tcl_AppendResult(interp, "bad argument "", argv[i+2],
  364.     "": should be "nonewline"", (char *) NULL);
  365.     return TCL_ERROR;
  366. }
  367. newline = 0;
  368.     }
  369.     if (i == (argc-1)) {
  370. fileId = "stdout";
  371.     } else {
  372. fileId = argv[i];
  373. i++;
  374.     }
  376.     if (strcmp(fileId, "stdout") == 0 || strcmp(fileId, "stderr") == 0) {
  377. char *result;
  378. int level;
  380. if (newline) {
  381.     int len = strlen(argv[i]);
  382.     result = ckalloc(len+2);
  383.     memcpy(result, argv[i], len);
  384.     result[len] = 'n';
  385.     result[len+1] = 0;
  386. } else {
  387.     result = argv[i];
  388. }
  389. if (strcmp(fileId, "stdout") == 0) {
  390.     level = MB_ICONINFORMATION;
  391. } else {
  392.     level = MB_ICONERROR;
  393. }
  394. OutputDebugString(result);
  395. ShowMessage(level, result);
  396. if (newline)
  397.     ckfree(result);
  398. return TCL_OK;
  399.     } else {
  400. extern int Tcl_PutsCmd(ClientData clientData, Tcl_Interp *interp,
  401.        int argc, char **argv);
  403. return (Tcl_PutsCmd(clientData, interp, argc, argv));
  404.     }
  405. }
  406. #endif
  408. int
  409. WinGetUserName(clientData, interp, argc, argv)
  410.     ClientData clientData;
  411.     Tcl_Interp *interp; /* Current interpreter. */
  412.     int argc; /* Number of arguments. */
  413.     char *argv[]; /* Argument strings. */
  414. {
  415.     char user[256];
  416.     int size = sizeof(user);
  417.     
  418.     if (!GetUserName(user, &size)) {
  419. Tcl_AppendResult(interp, "GetUserName failed", NULL);
  420. return TCL_ERROR;
  421.     }
  422.     Tcl_AppendResult(interp, user, NULL);
  423.     return TCL_OK;
  424. }
  426. int WinGetHostName(clientData, interp, argc, argv)
  427.                    ClientData clientData;
  428.                    Tcl_Interp *interp; /* Current interpreter. */
  429.                    int argc; /* Number of arguments. */
  430.                    char *argv[]; /* Argument strings. */               
  431. {
  432.         char hostname[MAXGETHOSTSTRUCT];
  433.         if (SOCKET_ERROR == gethostname(hostname, MAXGETHOSTSTRUCT)) {
  434.                 Tcl_AddErrorInfo(interp, "gethostname failed!");
  435.         }
  436.         Tcl_AppendResult(interp, hostname, NULL);
  437.         return TCL_OK;
  438. }
  440. static HKEY
  441. regroot(root)
  442.     char *root;
  443. {
  444.     if (strcasecmp(root, "HKEY_LOCAL_MACHINE") == 0)
  445. return HKEY_LOCAL_MACHINE;
  446.     else if (strcasecmp(root, "HKEY_CURRENT_USER") == 0)
  447. return HKEY_CURRENT_USER;
  448.     else if (strcasecmp(root, "HKEY_USERS") == 0)
  449. return HKEY_USERS;
  450.     else if (strcasecmp(root, "HKEY_CLASSES_ROOT") == 0)
  451. return HKEY_CLASSES_ROOT;
  452.     else
  453. return NULL;
  454. }
  456. int
  457. WinGetRegistry(clientData, interp, argc, argv)
  458.     ClientData clientData;
  459.     Tcl_Interp *interp; /* Current interpreter. */
  460.     int argc; /* Number of arguments. */
  461.     char **argv; /* Argument strings. */
  462. {
  463.     HKEY hKey, hRootKey;
  464.     DWORD dwType;
  465.     DWORD len, retCode;
  466.     CHAR *regRoot, *regPath, *keyValue, *keyData;
  467.     int retval = TCL_ERROR;
  468.     
  469.     if (argc != 3) {
  470. Tcl_AppendResult(interp, "wrong # args: should be "", argv[0],
  471. "key value"", (char *) NULL);
  472. return TCL_ERROR;
  473.     }
  474.     regRoot = argv[1];
  475.     keyValue = argv[2];
  477.     regPath = strchr(regRoot, '\');
  478.     *regPath++ = '';
  479.     
  480.     if ((hRootKey = regroot(regRoot)) == NULL) {
  481. Tcl_AppendResult(interp, "Unknown registry root "",
  482.  regRoot, """, NULL);
  483. return (TCL_ERROR);
  484.     }
  485.     
  486.     retCode = RegOpenKeyEx(hRootKey, regPath, 0,
  487.    KEY_READ, &hKey);
  488.     if (retCode == ERROR_SUCCESS) {
  489. retCode = RegQueryValueEx(hKey, keyValue, NULL, &dwType,
  490.   NULL, &len);
  491. if (retCode == ERROR_SUCCESS &&
  492.     dwType == REG_SZ && len) {
  493.     keyData = (CHAR *) ckalloc(len);
  494.     retCode = RegQueryValueEx(hKey, keyValue, NULL, NULL,
  495.       keyData, &len);
  496.     if (retCode == ERROR_SUCCESS) {
  497. Tcl_AppendResult(interp, keyData, NULL);
  498. free(keyData);
  499. retval = TCL_OK;
  500.     }
  501. }
  502. RegCloseKey(hKey);
  503.     }
  504.     if (retval == TCL_ERROR) {
  505. Tcl_AppendResult(interp, "Cannot find registry entry "", regRoot,
  506.  "\", regPath, "\", keyValue, """, NULL);
  507.     }
  508.     return (retval);
  509. }
  511. int
  512. WinPutRegistry(clientData, interp, argc, argv)
  513.     ClientData clientData;
  514.     Tcl_Interp *interp; /* Current interpreter. */
  515.     int argc; /* Number of arguments. */
  516.     char **argv; /* Argument strings. */
  517. {
  518.     HKEY hKey, hRootKey;
  519.     DWORD retCode;
  520.     CHAR *regRoot, *regPath, *keyValue, *keyData;
  521.     DWORD new;
  522.     int result = TCL_OK;
  523.     
  524.     if (argc != 4) {
  525. Tcl_AppendResult(interp, "wrong # args: should be "", argv[0],
  526. "key value data"", (char *) NULL);
  527. return TCL_ERROR;
  528.     }
  529.     regRoot = argv[1];
  530.     keyValue = argv[2];
  531.     keyData = argv[3];
  532.     
  533.     regPath = strchr(regRoot, '\');
  534.     *regPath++ = '';
  535.     
  536.     if ((hRootKey = regroot(regRoot)) == NULL) {
  537. Tcl_AppendResult(interp, "Unknown registry root "",
  538.  regRoot, """, NULL);
  539. return (TCL_ERROR);
  540.     }
  542.     retCode = RegCreateKeyEx(hRootKey, regPath, 0,
  543.      "",
  544.      REG_OPTION_NON_VOLATILE,
  545.      KEY_ALL_ACCESS,
  546.      NULL,
  547.      &hKey, &new);
  548.     if (retCode == ERROR_SUCCESS) {
  549. retCode = RegSetValueEx(hKey, keyValue, 0, REG_SZ, keyData, strlen(keyData));
  550. if (retCode != ERROR_SUCCESS) {
  551.     Tcl_AppendResult(interp, "unable to set key "", regRoot, "\",
  552.      regPath, "" with value "", keyValue, """,
  553.      (char *) NULL);
  554.     result = TCL_ERROR;
  555. }
  556. RegCloseKey(hKey);
  557.     }
  558.     else {
  559. Tcl_AppendResult(interp, "unable to create key "", regRoot, "\",
  560.  regPath, """, (char *) NULL);
  561. result = TCL_ERROR;
  562.     }
  563.     return (result);
  564. }
  566. int platformInit(Tcl_Interp* interp)
  567. {
  568.         /* tcl.CreateCommand("puts", WinPutsCmd, (ClientData)0); */
  569.         Tcl_CreateCommand(interp, "getusername", WinGetUserName,
  570.                           (ClientData)0, (Tcl_CmdDeleteProc*)0);
  571.         Tcl_CreateCommand(interp, "gethostname", WinGetHostName,
  572.                           (ClientData)0, (Tcl_CmdDeleteProc*)0);
  573.         Tcl_CreateCommand(interp, "putregistry", WinPutRegistry,
  574.                           (ClientData)0, (Tcl_CmdDeleteProc*)0);
  575.         Tcl_CreateCommand(interp, "getregistry", WinGetRegistry,
  576.                           (ClientData)0, (Tcl_CmdDeleteProc*)0);
  577.         
  578. #ifndef NO_TK
  579.         /*
  580.          * Initialize the console only if we are running as an interactive
  581.          * application.
  582.          */    
  583.         if (0==strcmp(Tcl_GetVar(interp, "tcl_interactive",
  584.                                  TCL_GLOBAL_ONLY), "1")) {
  585.                 /*
  586.                  * Create the console channels and install them as the standard
  587.                  * channels.  All I/O will be discarded until TkConsoleInit is
  588.                  * called to attach the console to a text widget.
  589.                  */            
  590.                 TkConsoleCreate();
  591.                 if (TkConsoleInit(interp) == TCL_ERROR) {
  592.                         fprintf(stderr, "error calling TkConsoleInitn");
  593.                 }
  594.         }
  595. #endif
  596.         return TCL_OK;
  597. }
  599. #endif
  601. static const char ISO_C_forbids_an_empty_source_file; /* don't know why ... */