晦涩的系统API

time_t 在 CE 和 PC 上编译不一致

玻璃小屋 — Fri, 25 Jul 2008 05:17:00 GMT

vs2005 以及以上在PC系统上，time_t 都编译成 64位的时间了（__time64_t）。
但是在CE系统上还是被编译成 32位的时间（__time32_t）。

问题就来了。。当用 socket 写程序时
定义这样的结构
struct
{
UINT uiCmd;
time_t uiCmdTime;
}

这时 PC 和 CE用socket 传递数据。问题就出来了。。。

不过 CE上面没有 time_t 类型的相关函数 time、gmtime 等~ 可能M$不推荐在CE上用time_t
自己注意一下。

Windows mobile 用CreateThread不会造成泄露~

玻璃小屋 — Wed, 23 Jul 2008 08:12:00 GMT

在win PC 系统上一般需要用 _beginthreadex 来开线程，而不是用CreateThread开线程，因为_beginthreadex 会对CRT的一些函数，比如 gmtime,strerror等函数申请(malloc)的临时内存进行释放。
具体代码可以在CRT源代码中查到，如下：

/***
*void WINAPI _freefls(void *) - free up a per-fiber data structure
*
*Purpose:
*       Called from _freeptd, as a callback from deleting a fiber, and
*       from deleting an FLS index. This routine frees up the per-fiber
*       buffer associated with a fiber that is going away. The tiddata
*       structure itself is freed, but not until its subordinate buffers
*       are freed.
*
*Entry:
*       pointer to a per-fiber data block (malloc-ed memory)
*
*Exit:
*
*Exceptions:
*
*******************************************************************************/

_CRTIMP void
WINAPI
_freefls (
    void *data
    )

{

    _ptiddata ptd;
    pthreadlocinfo ptloci;
    pthreadmbcinfo ptmbci;

    /*
     * Free up the _tiddata structure & its malloc-ed buffers.
     */

    ptd = data;
    if (ptd != NULL) {
        if(ptd->_errmsg)
            _free_crt((void *)ptd->_errmsg);

        if(ptd->_namebuf0)
            _free_crt((void *)ptd->_namebuf0);

        if(ptd->_namebuf1)
            _free_crt((void *)ptd->_namebuf1);

        if(ptd->_asctimebuf)
            _free_crt((void *)ptd->_asctimebuf);

        if(ptd->_wasctimebuf)
            _free_crt((void *)ptd->_wasctimebuf);

        if(ptd->_gmtimebuf)
            _free_crt((void *)ptd->_gmtimebuf);

        if(ptd->_cvtbuf)
            _free_crt((void *)ptd->_cvtbuf);

        if (ptd->_pxcptacttab != _XcptActTab)
            _free_crt((void *)ptd->_pxcptacttab);

        _mlock(_MB_CP_LOCK);
        __try {
            if ( ((ptmbci = ptd->ptmbcinfo) != NULL) &&
                 (InterlockedDecrement(&(ptmbci->refcount)) == 0) &&
                 (ptmbci != &__initialmbcinfo) )
                _free_crt(ptmbci);
        }
        __finally {
            _munlock(_MB_CP_LOCK);
        }

        _mlock(_SETLOCALE_LOCK);

        __try {
            if ( (ptloci = ptd->ptlocinfo) != NULL )
            {
                __removelocaleref(ptloci);
                if ( (ptloci != __ptlocinfo) &&
                     (ptloci != &__initiallocinfo) &&
                     (ptloci->refcount == 0) )
                    __freetlocinfo(ptloci);
            }
        }
        __finally {
            _munlock(_SETLOCALE_LOCK);
        }

        _free_crt((void *)ptd);
    }
    return;
}

/***
*void _freeptd(_ptiddata) - free up a per-thread data structure
*
*Purpose:
*       Called from _endthread and from a DLL thread detach handler,
*       this routine frees up the per-thread buffer associated with a
*       thread that is going away.  The tiddata structure itself is
*       freed, but not until its subordinate buffers are freed.
*
*Entry:
*       pointer to a per-thread data block (malloc-ed memory)
*       If NULL, the pointer for the current thread is fetched.
*
*Exit:
*
*Exceptions:
*
*******************************************************************************/

void __cdecl _freeptd (
        _ptiddata ptd
        )
{
        /*
         * Do nothing unless per-thread data has been allocated for this module!
         */

        if ( __flsindex != FLS_OUT_OF_INDEXES ) {

            /*
             * if parameter "ptd" is NULL, get the per-thread data pointer
             * Must NOT call _getptd because it will allocate one if none exists!
             * If FLS_GETVALUE is NULL then ptd could not have been set
             */

            if ( ptd == NULL
#ifdef _M_IX86
                 && (FLS_GETVALUE != NULL)
#endif  /* _M_IX86 */
                )
                ptd = FLS_GETVALUE(__flsindex);

            /*
             * Zero out the one pointer to the per-thread data block
             */

            FLS_SETVALUE(__flsindex, (LPVOID)0);

            _freefls(ptd);
        }

#ifdef _M_IX86
        if ( __getvalueindex != TLS_OUT_OF_INDEXES ) {
            /*
             * Zero out the FlsGetValue pointer
             */
            TlsSetValue(__getvalueindex, (LPVOID)0);
        }
#endif  /* _M_IX86 */
}

而在win mobile( wince)系统中没有这些顾虑！因为在 wm (ce) 上面根本就没有提供造成申请线程全局内存的函数。。比如 gmtime strerror等在CE上都没有被提供。所以也不会造成内存泄露~证据如下：

#if !defined(_WIN32_WCE)
/* These are not supported on CE */
using ::strcoll; using ::strerror; using ::strxfrm;
#endif

#if !defined(_WIN32_WCE)
// These are not supported on CE
using ::freopen; using ::getc; using ::perror;
using ::putc;
using ::remove; using ::rename; using ::rewind;
using ::setbuf; using ::tmpfile; using ::tmpnam;
#endif

#if !defined(_WIN32_WCE)
using ::asctime; using ::clock; using ::ctime;
using ::gmtime; using ::localtime;
using ::mktime; using ::strftime; using ::time;
#endif /* _WIN32_WCE */

还有一个证据就是 CE上的 MFC 实现的 CWinThread类，他开线程也是用的CreateThread

BOOL CWinThread::CreateThread(DWORD dwCreateFlags, UINT nStackSize,
    LPSECURITY_ATTRIBUTES lpSecurityAttrs)
{
#ifndef _MT
    dwCreateFlags;
    nStackSize;
    lpSecurityAttrs;

    return FALSE;
#else
    ENSURE(m_hThread == NULL);  // already created?

    // setup startup structure for thread initialization
    _AFX_THREAD_STARTUP startup; memset(&startup, 0, sizeof(startup));
    startup.pThreadState = AfxGetThreadState();
    startup.pThread = this;
    startup.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    startup.hEvent2 = ::CreateEvent(NULL, TRUE, FALSE, NULL);
    startup.dwCreateFlags = dwCreateFlags;
    if (startup.hEvent == NULL || startup.hEvent2 == NULL)
    {
        TRACE(traceAppMsg, 0, _T("Warning: CreateEvent failed in CWinThread::CreateThread. "));
        if (startup.hEvent != NULL)
            ::CloseHandle(startup.hEvent);
        if (startup.hEvent2 != NULL)
            ::CloseHandle(startup.hEvent2);
        return FALSE;
    }

    // create the thread (it may or may not start to run)
#ifndef _WIN32_WCE
    m_hThread = (HANDLE)(ULONG_PTR)_beginthreadex(lpSecurityAttrs, nStackSize,
        &_AfxThreadEntry, &startup, dwCreateFlags | CREATE_SUSPENDED, (UINT*)&m_nThreadID);
#else
    m_hThread = (HANDLE)(ULONG_PTR)::CreateThread(lpSecurityAttrs, nStackSize,
        (LPTHREAD_START_ROUTINE)&_AfxThreadEntry, &startup, dwCreateFlags | CREATE_SUSPENDED, (LPDWORD)&m_nThreadID);
#endif // !_WIN32_WCE
    if (m_hThread == NULL)
    {
        ::CloseHandle(startup.hEvent);
        ::CloseHandle(startup.hEvent2);
        return FALSE;
    }

    // start the thread just for MFC initialization
    VERIFY(ResumeThread() != (DWORD)-1);
    VERIFY(::WaitForSingleObject(startup.hEvent, INFINITE) == WAIT_OBJECT_0);
    ::CloseHandle(startup.hEvent);

    // if created suspended, suspend it until resume thread wakes it up
    if (dwCreateFlags & CREATE_SUSPENDED)
        VERIFY(::SuspendThread(m_hThread) != (DWORD)-1);

    // if error during startup, shut things down
    if (startup.bError)
    {
        VERIFY(::WaitForSingleObject(m_hThread, INFINITE) == WAIT_OBJECT_0);
        ::CloseHandle(m_hThread);
        m_hThread = NULL;
        ::CloseHandle(startup.hEvent2);
        return FALSE;
    }

    // allow thread to continue, once resumed (it may already be resumed)
    VERIFY(::SetEvent(startup.hEvent2));
    return TRUE;
#endif //!_MT
}

CRITICAL_SECTION M$网站上的文章。

玻璃小屋 — Fri, 16 May 2008 02:52:00 GMT

http://www.microsoft.com/china/MSDN/library/enterprisedevelopment/softwaredev/ousCriticalSections.mspx

WSARecv 投递缓冲区也要对齐？？？不然就10014!

玻璃小屋 — Tue, 06 May 2008 17:23:00 GMT

如果把下面代码中背景色为绿色部分的 int iAlign = 4; 其中的 4 改为1或2，WSARecv就会返回 10014 错误。看来WSARecv 的投递的缓冲区也是要求对齐的。。正是因为这个问题。。浪费了我一天的时间调试我的内存池代码。。5555555555

#include <stdio.h>
#include "winsock2.h"

#define DATA_BUFSIZE 4096

void main() {
  //-----------------------------------------
  // Declare and initialize variables
  WSABUF DataBuf;
  char buffer[DATA_BUFSIZE];
  DWORD EventTotal = 0,
    RecvBytes = 0,
    Flags = 0,
    BytesTransferred = 0,
    CallBack = 0;
  WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS];
  WSAOVERLAPPED AcceptOverlapped;
  SOCKET ListenSocket, AcceptSocket;

  //-----------------------------------------
  // Initialize Winsock
  WSADATA wsaData;
  WSAStartup(MAKEWORD(2,2), &wsaData);

  //-----------------------------------------
  // Create a listening socket bound to a local
  // IP address and the port specified
  ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  u_short port = 27015;
  char* ip;
  sockaddr_in service;
  service.sin_family = AF_INET;
  service.sin_port = htons(port);
  hostent* thisHost;
  thisHost = gethostbyname("");
  ip = inet_ntoa (*(struct in_addr *)*thisHost->h_addr_list);

  service.sin_addr.s_addr = inet_addr(ip);

  //-----------------------------------------
  // Bind the listening socket to the local IP address
  // and port number
  bind(ListenSocket, (SOCKADDR *) &service, sizeof(SOCKADDR));

  //-----------------------------------------
  // Set the socket to listen for incoming
  // connection requests
  listen(ListenSocket, 1);
  printf("Listening ");

  //-----------------------------------------
  // Accept and incoming connection request
  AcceptSocket = accept(ListenSocket, NULL, NULL);
  printf("Client Accepted ");

  //-----------------------------------------
  // Create an event handle and setup an overlapped structure.
  EventArray[EventTotal] = WSACreateEvent();
  ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED));
  AcceptOverlapped.hEvent = EventArray[EventTotal];
  DataBuf.len = DATA_BUFSIZE;
  DataBuf.buf = buffer;
  EventTotal++;

  LPWSABUF lpwsaBuf;

  //int iAlign = 1;
  int iAlign = 4;

  lpwsaBuf = (LPWSABUF) ((new CHAR[sizeof(WSABUF) + iAlign]) + iAlign);//pOverlapBuff->GetWSABuffer();
  lpwsaBuf->buf = new CHAR[52];
  lpwsaBuf->len = 52;

  //-----------------------------------------
  // Call WSARecv to receive data into DataBuf on
  // the accepted socket in overlapped I/O mode
  if (WSARecv(AcceptSocket, lpwsaBuf, 1, &RecvBytes, &Flags, &AcceptOverlapped, NULL) == SOCKET_ERROR)
  {
      if (WSAGetLastError() != WSA_IO_PENDING)
      {
          printf("Error occured at WSARecv() %d ",WSAGetLastError());
          closesocket(AcceptSocket);
          return;
      }
  }

  //-----------------------------------------
  // Process overlapped receives on the socket
  while (1) {
    DWORD Index;

    //-----------------------------------------
    // Wait for the overlapped I/O call to complete
    Index = WSAWaitForMultipleEvents(EventTotal, EventArray, FALSE, WSA_INFINITE, FALSE);

    //-----------------------------------------
    // Reset the signaled event
    WSAResetEvent(EventArray[Index - WSA_WAIT_EVENT_0]);

    //-----------------------------------------
    // Determine the status of the overlapped event
    WSAGetOverlappedResult(AcceptSocket, &AcceptOverlapped, &BytesTransferred, FALSE, &Flags);

    //-----------------------------------------
    // If the connection has been closed, close the accepted socket
    if (BytesTransferred == 0) {
      printf("Closing Socket %d ", AcceptSocket);
      closesocket(AcceptSocket);
      WSACloseEvent(EventArray[Index - WSA_WAIT_EVENT_0]);
      return;
    }

    //-----------------------------------------
    // If data has been received, echo the received data
    // from DataBuf back to the client
    if (WSASend(AcceptSocket, &DataBuf, 1, &RecvBytes, Flags, &AcceptOverlapped, NULL) == SOCKET_ERROR)
      printf("WSASend() is busted ");

    //-----------------------------------------
    // Reset the changed flags and overlapped structure
    Flags = 0;
    ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED));

    AcceptOverlapped.hEvent = EventArray[Index - WSA_WAIT_EVENT_0];

    //-----------------------------------------
    // Reset the data buffer
    DataBuf.len = DATA_BUFSIZE;
    DataBuf.buf = buffer;
  }
}