iraddr.irdaDeviceID[i] = 0;
    memcpy (iraddr.irdaServiceName, chzAppName, sizeof (chzAppName) + 1);

    // 僜働僢僩傪傾僪儗僗偵娭楢晅偗傞
    rc = bind (s_sock, (struct sockaddr *)&iraddr, sizeof (iraddr));
    if (rc) {
        Add2List (hWnd, TEXT (" bind failed"));
        closesocket (s_sock);
        return -2;
    }
    // 僜働僢僩傪儕僗儞忬懺偵偡傞
    rc = listen (s_sock, SOMAXCONN);
    if (rc == SOCKET_ERROR) {
        Add2List (hWnd, TEXT (" listen failed %d"), GetLastError());
        closesocket (s_sock);
        return -3;
    }
    // 儕儌乕僩 僨僶僀僗偐傜偺梫媮傪懸婡偡傞
    while (fContinue) {
        // accept娭悢偵懳偟偰僽儘僢僋偡傞
        nSize = sizeof (t_iraddr);
        t_sock = accept (s_sock, (struct sockaddr *)&t_iraddr, &nSize);
        if (t_sock == INVALID_SOCKET) {
            Add2List (hWnd, TEXT (" accept failed %d"),
                      GetLastError());
            break;
        }
        Add2List (hWnd, TEXT ("sock accept..."));
        hThread = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE)SenderThread,
                                (PVOID)t_sock, 0, &rc);
        if (hThread)
            CloseHandle (hThread);
    }
    closesocket (s_sock);
    return rc;
}
//======================================================================
// SenderThread - 儕儌乕僩 僨僶僀僗偑梫媮偟偨僼傽僀儖傪憲傞
//
int SenderThread (PVOID pArg) {
    SOCKET t_sock = (SOCKET)pArg;
    int nCnt, nFileSize, rc;
    TCHAR szFileName[_MAX_PATH];
    PBYTE pBuff, pPtr;
    HWND hWnd = hMain;
    HANDLE hFile;

    Add2List (hWnd, TEXT ("sender thread entered"));

    // 僜働僢僩偐傜僼傽僀儖柤偺僒僀僘傪撉傒庢?zhèn)?    rc = recv (t_sock, (PBYTE)&nCnt, sizeof (nCnt), 0);
    if ((rc == SOCKET_ERROR) || (nCnt > _MAX_PATH)) {
        Add2List (hWnd, TEXT ("failed receiving name size"));
        closesocket (t_sock);
        return -1;
    }

    // 僜働僢僩偐傜僼傽僀儖柤傪撉傒庢?zhèn)?    rc = recv (t_sock, (PBYTE)&szFileName, nCnt, 0);
    if (rc == SOCKET_ERROR) {
        Add2List (hWnd, TEXT ("failed receiving name"));
        closesocket (t_sock);
        return -2;
    }
    Add2List (hWnd, TEXT ("name: %s"), szFileName);
    hFile = CreateFile (szFileName, GENERIC_READ, FILE_SHARE_READ,
                        NULL, OPEN_EXISTING, 0, NULL);
    if (hFile == INVALID_HANDLE_VALUE) {
        Add2List (hWnd, TEXT ("file opened failed. rc %d"),
                  GetLastError());
        rc = BAD_FILEOPEN;
    } else {
        rc = 0;
        nFileSize = GetFileSize (hFile, NULL);

        // 僶僢僼傽傪妱傝摉偰偰僼傽僀儖傪撉傒庢?zhèn)?        pBuff = LocalAlloc (LPTR, nFileSize);
        if (pBuff) {
            ReadFile (hFile, pBuff, nFileSize, &nCnt, NULL);
            if (nCnt != nFileSize)
                rc = BAD_FILEREAD;
        } else
            rc = BAD_MEMORY;
    }
    // 揮憲傪奐巒偡傞丅傑偢僒僀僘傪憲怣偟丄墳摎僐乕僪傪庴偗庢?zhèn)閬B
    if (!rc) {
        // 僼傽僀儖偺僒僀僘傪憲傞丅僼傽僀儖偺僒僀僘偼2GB枹枮偱偁傞偲壖掕偡傞丅
        rc = send (t_sock, (PBYTE)&nFileSize, sizeof (nFileSize), 0);
        if (rc == SOCKET_ERROR)
            rc = BAD_SOCKET;
        else
            // 僼傽僀儖偺僒僀僘偺墳摎僐乕僪傪撉傒庢?zhèn)?            recv (t_sock, (PBYTE)&rc, sizeof (rc), 0);
    }
    // 僼傽僀儖傪憲傞
    pPtr = pBuff;
    while ((!rc) && nFileSize) {
        // 傑偢丄僽儘僢僋偺僒僀僘傪憲傞
        nCnt = min (BLKSIZE, nFileSize);
        rc = send (t_sock, pPtr, nCnt, 0);
        if (rc == SOCKET_ERROR) {
            Add2List (hWnd, TEXT ("send error %d "), GetLastError());
            rc = BAD_SOCKET;
        } else
            Add2List (hWnd, TEXT ("sent %d bytes"), rc);
        pPtr += rc;
        nFileSize -= rc;

        // 墳摎僐乕僪傪撉傒庢?zhèn)?        recv (t_sock, (PBYTE)&rc, sizeof (rc), 0);
    }
    // 廔椆僐乕僪傪憲傞
    if (rc != BAD_SOCKET)
        send (t_sock, (PBYTE)&rc, sizeof (rc), 0);

    closesocket (t_sock);
    // 僋儕乕儞傾僢僾張棟
    if (hFile != INVALID_HANDLE_VALUE)
        CloseHandle (hFile);
    LocalFree (pBuff);
    Add2List (hWnd, TEXT ("sender thread exit"));
    return 0;
}
//----------------------------------------------------------------------
// GetFile - 儕儌乕僩 僨僶僀僗偐傜僼傽僀儖傪庴怣偡傞
//
int GetFile (HWND hWnd, TCHAR *szFileName) {
    SOCKET c_sock;
    HANDLE hFile;
    INT rc, nSize, i, nFileSize, nCnt;
    char cDevice[256];
    SOCKADDR_IRDA iraddr;
    DEVICELIST *pDL;
    STORE_INFORMATION si;
    PBYTE pBuff;

    // IrDA僜働僢僩傪奐偔
    c_sock = socket (AF_IRDA, SOCK_STREAM, 0);
    if (c_sock == INVALID_SOCKET) {
        Add2List (hWnd, TEXT ("sock failed. rc %d"), WSAGetLastError());
        return 0;
    }
    // 捠怣偡傞僨僶僀僗傪専嶕偡傞
    for (i = 0; i < 5; i++) {
        memset (cDevice, 0, sizeof (cDevice));
        nSize = sizeof (cDevice);
        rc = getsockopt (c_sock, SOL_IRLMP, IRLMP_ENUMDEVICES,
                         cDevice, &nSize);
        if (rc)
            Add2List (hWnd, TEXT ("getsockopt failed. rc %d"),
                      WSAGetLastError());

        pDL = (DEVICELIST *)cDevice;
        if (pDL->numDevice)
            break;
        Sleep(500);
    }
    // 僨僶僀僗傪敪尒偱偒側(cè)偐偭偨偲偒偼廔椆偡傞
    if (pDL->numDevice == 0) {
        closesocket (c_sock);
        return -1;
    }

    // 尒偮偗偨僨僶僀僗偺傾僪儗僗傪僐僺乕偡傞
    memset (&iraddr, 0, sizeof (iraddr));
    iraddr.irdaAddressFamily = AF_IRDA;
    memcpy (iraddr.irdaDeviceID, pDL->Device[0].irdaDeviceID, 4);
    // 巊梡偡傞僜働僢僩傪弶婜壔偡傞
    memcpy (iraddr.irdaServiceName, chzAppName, sizeof (chzAppName) + 1);

    Add2List (hWnd, TEXT ("Found: %hs"), pDL->Device[0].irdaDeviceName);
    // 儕儌乕僩 僨僶僀僗偵愙懕偡傞
    rc = connect (c_sock, (struct sockaddr *)&iraddr, sizeof (iraddr));
    if (rc) {
        Add2List (hWnd, TEXT ("connect failed. rc %d"),
                  WSAGetLastError());
        closesocket (c_sock);
        return -4;
    }
    Add2List (hWnd, TEXT ("connected..."));

    // 僼傽僀儖柤偺僒僀僘傪憲傞
    nCnt = (lstrlen (szFileName) + 1) * sizeof (TCHAR);
    rc = send (c_sock, (PBYTE)&nCnt, sizeof (nCnt), 0);
    if (rc != SOCKET_ERROR) {
        // 僼傽僀儖柤傪憲傞
        rc = send (c_sock, (PBYTE)szFileName, nCnt, 0);
    }
    // 僼傽僀儖偺庴怣僶僢僼傽傪妱傝摉偰傞
    pBuff = LocalAlloc (LPTR, BLKSIZE);
    // 僼傽僀儖偺僒僀僘傪撉傒庢?zhèn)?    rc = recv (c_sock, (PBYTE)&nFileSize, sizeof (nFileSize), 0);
    Add2List (hWnd, TEXT ("received file size of %d bytes"), nFileSize);
    if ((rc != SOCKET_ERROR) && (nFileSize > 0)) {

        GetStoreInformation (&si);
        Add2List (hWnd, TEXT ("free space of %d bytes"), si.dwFreeSize);
        if ((INT)si.dwFreeSize < nFileSize + 1000)
            rc = BAD_FILESIZE;
        else
            rc = GOOD_XFER;

        if (rc == GOOD_XFER) {
            // 僋儔僀傾儞僩懁偱僼傽僀儖傪嶌惉偡傞
            // 僼傽僀儖偑婛偵懚嵼偡傞応崌丄儐乕僓乕偑忋彂偒傪巜帵偟偨偲偒偺傒丄
            // 僼傽僀儖傪忋彂偒偡傞
            hFile = CreateFile (szFileName, GENERIC_WRITE, 0, NULL,
                                CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
            if (hFile == INVALID_HANDLE_VALUE) {
                if (GetLastError() == ERROR_FILE_EXISTS) {
                    i = MessageBox (hWnd,
                                    TEXT ("File already exists. Replace?"),
                                    szAppName, MB_YESNO);
                    if (i == IDYES)
                        hFile = CreateFile (szFileName,
                                            GENERIC_WRITE, 0, NULL,
                                            CREATE_ALWAYS,
                                            FILE_ATTRIBUTE_NORMAL, NULL);
                }
            }
        }
        if (hFile == INVALID_HANDLE_VALUE) {
            Add2List (hWnd, TEXT ("File Open failed. rc %d"),
                      GetLastError());
            rc = BAD_FILEWRITE;
        }
        // 墳摎僐乕僪傪憲傞
        Add2List (hWnd, TEXT ("Sending size ack."));
        send (c_sock, (PBYTE)&rc, sizeof (rc), 0);
        //
        // 僼傽僀儖傪庴偗庢?zhèn)?        //
        while ((!rc) && (nFileSize > 0)) {

            nCnt = min (BLKSIZE, nFileSize);
            for (nSize = 0; nSize < nCnt;) {
                i = recv (c_sock, pBuff + nSize, nCnt - nSize, 0);
                if (i == SOCKET_ERROR) {
                    Add2List (hWnd, TEXT ("recv socket err %d"),
                              GetLastError());
                    rc = BAD_SOCKETRECV;
                    break;
                }
                nSize += i;
            }
            Add2List (hWnd, TEXT ("recv\'d %d bytes."), nSize);
            if (i) {
                if (!WriteFile (hFile, pBuff, nSize, &i, 0))
                    rc = BAD_FILEWRITE;
                nFileSize -= i;
            } else
                Sleep(50);
            // 僷働僢僩偺墳摎僐乕僪傪憲傞
            send (c_sock, (PBYTE)&rc, sizeof (rc), 0);
        }
    } else if (rc == BAD_FILEOPEN)
        Add2List (hWnd, TEXT ("File not found."));
    Add2List (hWnd, TEXT ("receive finished"));

    CloseHandle (hFile);
    closesocket (c_sock);
    LocalFree (pBuff);
    return 0;
}