注册注销登录退出jabber

最新推荐文章于 2023-07-27 09:30:07 发布
最新推荐文章于 2023-07-27 09:30:07 发布
阅读量3.3k 收藏 1
点赞数
分类专栏： Miranda IM 文章标签： null thread ssl session buffer login
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hurtmanzc/article/details/1799990
版权
 
注册Jabber用户
static BOOL CALLBACK JabberRegisterDlgProc( HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
       ThreadData *thread, *regInfo;
 
       switch ( msg ) {
       case WM_INITDIALOG:
       {
              TranslateDialogDefault( hwndDlg );
              regInfo = ( ThreadData* ) lParam;
              TCHAR text[256];
              mir_sntprintf( text, SIZEOF(text), STR_FORMAT, TranslateT( "Register" ), regInfo->username, regInfo->server, regInfo->port );
              SetDlgItemText( hwndDlg, IDC_REG_STATUS, text );
              SetWindowLong( hwndDlg, GWL_USERDATA, ( LONG )regInfo );
              return TRUE;
       }
       case WM_COMMAND:
              switch ( LOWORD( wParam )) {
              case IDOK:
                     ShowWindow( GetDlgItem( hwndDlg, IDOK ), SW_HIDE );
                     ShowWindow( GetDlgItem( hwndDlg, IDCANCEL ), SW_HIDE );
                     ShowWindow( GetDlgItem( hwndDlg, IDC_PROGRESS_REG ), SW_SHOW );
                     ShowWindow( GetDlgItem( hwndDlg, IDCANCEL2 ), SW_SHOW );
                     regInfo = ( ThreadData* ) GetWindowLong( hwndDlg, GWL_USERDATA );
                     thread = new ThreadData( JABBER_SESSION_REGISTER );
                     _tcsncpy( thread->username, regInfo->username, SIZEOF( thread->username ));
                     strncpy( thread->password, regInfo->password, SIZEOF( thread->password ));
                     strncpy( thread->server, regInfo->server, SIZEOF( thread->server ));
                     strncpy( thread->manualHost, regInfo->manualHost, SIZEOF( thread->manualHost ));
                     thread->port = regInfo->port;
                     thread->useSSL = regInfo->useSSL;
                     thread->reg_hwndDlg = hwndDlg;
                     mir_forkthread(( pThreadFunc )JabberServerThread, thread );
                     return TRUE;
              case IDCANCEL:
              case IDOK2:
                     EndDialog( hwndDlg, 0 );
                     return TRUE;
              }
              break;
       case WM_JABBER_REGDLG_UPDATE:     // wParam=progress ( 0-100 ), lparam=status string
              if (( TCHAR* )lParam == NULL )
                     SetDlgItemText( hwndDlg, IDC_REG_STATUS, TranslateT( "No message" ));
              else
                     SetDlgItemText( hwndDlg, IDC_REG_STATUS, ( TCHAR* )lParam );
              if ( wParam >= 0 )
                     SendMessage( GetDlgItem( hwndDlg, IDC_PROGRESS_REG ), PBM_SETPOS, wParam, 0 );
              if ( wParam >= 100 ) {
                     ShowWindow( GetDlgItem( hwndDlg, IDCANCEL2 ), SW_HIDE );
                     ShowWindow( GetDlgItem( hwndDlg, IDOK2 ), SW_SHOW );
              }
              else SetFocus( GetDlgItem( hwndDlg, IDC_PROGRESS_REG ));
              return TRUE;
       }
 
       return FALSE;
}
 
登录Jabber
JabberServerThread
都在线程JabberServerThread里, 在程序里加了注释, 仔细分析代码吧:
void __cdecl JabberServerThread( ThreadData* info )
{
       DBVARIANT dbv;
       char* buffer;
       int datalen;
       int oldStatus;
       PVOID ssl;
 
       JabberLog( "Thread started: type=%d", info->type );
 
       info->resolveID = -1;
       info->auth = NULL;
       if ( info->type == JABBER_SESSION_NORMAL )
    {
              // Normal server connection, we will fetch all connection parameters
              // e.g. username, password, etc. from the database.
 
              if ( jabberThreadInfo != NULL )
        {
                     // Will not start another connection thread if a thread is already running.
                     // Make APC call to the main thread. This will immediately wake the thread up
                     // in case it is asleep in the reconnect loop so that it will immediately
                     // reconnect.
                     QueueUserAPC( JabberDummyApcFunc, jabberThreadInfo->hThread, 0 );
                     JabberLog( "Thread ended, another normal thread is running" );
                     //zhangcong//mir_free( info );
            delete info; info = NULL; //zhangcong
                     return;
              }
 
              jabberThreadInfo = info;
              if ( streamId )
            mir_free( streamId );
              streamId = NULL;
 
        //读取登录帐号
              if ( !JGetStringT( NULL, "LoginName", &dbv )) {
                     _tcsncpy( info->username, dbv.ptszVal, SIZEOF( info->username )-1 );
                     JFreeVariant( &dbv );
              }
              else {
                     JabberLog( "Thread ended, login name is not configured" );
                     JSendBroadcast( NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGINERR_BADUSERID );
LBL_FatalError:
                     jabberThreadInfo = NULL;
                     oldStatus = jabberStatus;
                     jabberStatus = ID_STATUS_OFFLINE;
                     JSendBroadcast( NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, ( HANDLE ) oldStatus, jabberStatus );
LBL_Exit:
                     //zhangcong//mir_free( info );
            delete info; info = NULL; //zhangcong
                     return;
              }
 
              if ( *rtrim(info->username) == '/0' ) {
                     JabberLog( "Thread ended, login name is not configured" );
                     JSendBroadcast( NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGINERR_BADUSERID );
                     goto LBL_FatalError;
              }
 
        //读取jabber server地址
              if ( !DBGetContactSetting( NULL, jabberProtoName, "LoginServer", &dbv )) {
                     strncpy( info->server, dbv.pszVal, SIZEOF( info->server )-1 );
                     JFreeVariant( &dbv );
              }
              else {
                     JSendBroadcast( NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGINERR_NONETWORK );
                     JabberLog( "Thread ended, login server is not configured" );
                     goto LBL_FatalError;
              }
 
        //读取资源 (在注册用户时指定的)
              if ( !JGetStringT( NULL, "Resource", &dbv )) {
                     _tcsncpy( info->resource, dbv.ptszVal, SIZEOF( info->resource )-1 );
                     JFreeVariant( &dbv );
              }
              else
        {
            _tcscpy( info->resource, _T("Miranda"));
        }
 
        //构造出完整的Jabber ID
              TCHAR jidStr[128];
              mir_sntprintf( jidStr, SIZEOF( jidStr ), _T("%s@") _T(TCHAR_STR_PARAM) _T("/%s"), info->username, info->server, info->resource );
              _tcsncpy( info->fullJID, jidStr, SIZEOF( info->fullJID )-1 );
 
        //读取登录密码, 如果已经保存的话
              if ( JGetByte( "SavePassword", TRUE ) == FALSE )
        {
                     mir_sntprintf( jidStr, SIZEOF( jidStr ), _T("%s@") _T(TCHAR_STR_PARAM), info->username, info->server );
 
                     // Ugly hack: continue logging on only the return value is &( onlinePassword[0] )
                     // because if WM_QUIT while dialog box is still visible, p is returned with some
                     // exit code which may not be NULL.
                     // Should be better with modeless.
                     onlinePassword[0] = ( char )-1;
                     hEventPasswdDlg = CreateEvent( NULL, FALSE, FALSE, NULL );
                     QueueUserAPC( JabberPasswordCreateDialogApcProc, hMainThread, ( DWORD )jidStr );
                     WaitForSingleObject( hEventPasswdDlg, INFINITE );
                     CloseHandle( hEventPasswdDlg );
 
                     if ( onlinePassword[0] == ( TCHAR ) -1 ) {
                            JSendBroadcast( NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGINERR_BADUSERID );
                            JabberLog( "Thread ended, password request dialog was canceled" );
                            goto LBL_FatalError;
                     }
                     strncpy( info->password, onlinePassword, SIZEOF( info->password ));
                     info->password[ SIZEOF( info->password )-1] = '/0';
              }
              else {
                     if ( DBGetContactSetting( NULL, jabberProtoName, "Password", &dbv )) {
                            JSendBroadcast( NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGINERR_BADUSERID );
                            JabberLog( "Thread ended, password is not configured" );
                            goto LBL_FatalError;
                     }
                     JCallService( MS_DB_CRYPT_DECODESTRING, strlen( dbv.pszVal )+1, ( LPARAM )dbv.pszVal );
                     strncpy( info->password, dbv.pszVal, SIZEOF( info->password ));
                     info->password[SIZEOF( info->password )-1] = '/0';
                     JFreeVariant( &dbv );
              }
 
        //读取jabber server端口, 如果指定了Jabber server地址的话, 读取指定的地址
              if ( JGetByte( "ManualConnect", FALSE ) == TRUE ) {
                     if ( !DBGetContactSetting( NULL, jabberProtoName, "ManualHost", &dbv )) {
                            strncpy( info->manualHost, dbv.pszVal, SIZEOF( info->manualHost ));
                            info->manualHost[sizeof( info->manualHost )-1] = '/0';
                            JFreeVariant( &dbv );
                     }
                     info->port = JGetWord( NULL, "ManualPort", JABBER_DEFAULT_PORT );
              }
              else
        {
            info->port = JGetWord( NULL, "Port", JABBER_DEFAULT_PORT );
        }
 
        //是否使用SSL
              info->useSSL = JGetByte( "UseSSL", FALSE );
       }
 
       else if ( info->type == JABBER_SESSION_REGISTER ) //注册新用户连接
    {
              // Register new user connection, all connection parameters are already filled-in.
              // Multiple thread allowed, although not possible : )
              // thinking again.. multiple thread should not be allowed
              info->reg_done = FALSE;
              SendMessage( info->reg_hwndDlg, WM_JABBER_REGDLG_UPDATE, 25, ( LPARAM )TranslateT( "Connecting..." ));
              iqIdRegGetReg = -1;
              iqIdRegSetReg = -1;
       }
       else
    {
              JabberLog( "Thread ended, invalid session type" );
              goto LBL_Exit;
       }
 
       char connectHost[128];
       if ( info->manualHost[0] == 0 ) {
              int port_temp;
              strncpy( connectHost, info->server, SIZEOF(info->server));
              if ( port_temp = xmpp_client_query( connectHost )) { // port_temp will be > 0 if resolution is successful
                     JabberLog("%s%s resolved to %s:%d","_xmpp-client._tcp.",info->server,connectHost,port_temp);
                     if (info->port==0 || info->port==5222)
                            info->port = port_temp;
              }
              else JabberLog("%s%s not resolved", "_xmpp-client._tcp.", connectHost);
       }
       else
    {
        strncpy( connectHost, info->manualHost, SIZEOF(connectHost)); // do not resolve if manual host is selected
    }
 
       JabberLog( "Thread type=%d server='%s' port='%d'", info->type, connectHost, info->port );
 
       int jabberNetworkBufferSize = 2048;
       if (( buffer=( char* )mir_alloc( jabberNetworkBufferSize+1 )) == NULL ) {     // +1 is for '/0' when debug logging this buffer
              JabberLog( "Cannot allocate network buffer, thread ended" );
              if ( info->type == JABBER_SESSION_NORMAL ) {
                     oldStatus = jabberStatus;
                     jabberStatus = ID_STATUS_OFFLINE;
                     JSendBroadcast( NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGINERR_NONETWORK );
                     JSendBroadcast( NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, ( HANDLE ) oldStatus, jabberStatus );
                     jabberThreadInfo = NULL;
              }
              else if ( info->type == JABBER_SESSION_REGISTER ) {
                     SendMessage( info->reg_hwndDlg, WM_JABBER_REGDLG_UPDATE, 100, ( LPARAM )TranslateT( "Error: Not enough memory" ));
              }
              JabberLog( "Thread ended, network buffer cannot be allocated" );
              goto LBL_Exit;
       }
 
    //与Jabber server建立socket连接
       info->s = JabberWsConnect( connectHost, info->port );
       if ( info->s == NULL )
    {
              JabberLog( "Connection failed ( %d )", WSAGetLastError());
              if ( info->type == JABBER_SESSION_NORMAL )
        {
                     if ( jabberThreadInfo == info )
            {
                            oldStatus = jabberStatus;
                            jabberStatus = ID_STATUS_OFFLINE;
                            JSendBroadcast( NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGINERR_NONETWORK );
                            JSendBroadcast( NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, ( HANDLE ) oldStatus, jabberStatus );
                            jabberThreadInfo = NULL;
            }    
        }
              else if ( info->type == JABBER_SESSION_REGISTER )
        {
                     SendMessage( info->reg_hwndDlg, WM_JABBER_REGDLG_UPDATE, 100, ( LPARAM )TranslateT( "Error: Cannot connect to the server" ));
        }
 
              JabberLog( "Thread ended, connection failed" );
              mir_free( buffer );
              goto LBL_Exit;
       }
 
       // Determine local IP
       int socket = JCallService( MS_NETLIB_GETSOCKET, ( WPARAM ) info->s, 0 );
       if ( info->type==JABBER_SESSION_NORMAL && socket!=INVALID_SOCKET ) {
              struct sockaddr_in saddr;
              int len;
 
              len = sizeof( saddr );
              getsockname( socket, ( struct sockaddr * ) &saddr, &len );
              jabberLocalIP = saddr.sin_addr.S_un.S_addr;
              JabberLog( "Local IP = %s", inet_ntoa( saddr.sin_addr ));
       }
 
       if ( info->useSSL )
    {
              JabberLog( "Intializing SSL connection" );
              if ( JabberSslInit() && socket != INVALID_SOCKET )
        {
                     JabberLog( "SSL using socket = %d", socket );
                     if (( ssl=pfn_SSL_new( jabberSslCtx )) != NULL )
            {
                            JabberLog( "SSL create context ok" );
                            if ( pfn_SSL_set_fd( ssl, socket ) > 0 )
                {
                                   JabberLog( "SSL set fd ok" );
                                   if ( pfn_SSL_connect( ssl ) > 0 )
                    {
                                          JabberLog( "SSL negotiation ok" );
                                          info->ssl = ssl;       // This make all communication on this handle use SSL
                                          JabberLog( "SSL enabled for handle = %d", info->s );
                                   }
                                   else
                    {
                                          JabberLog( "SSL negotiation failed" );
                                          pfn_SSL_free( ssl );
                    }    
                }
                            else
                {
                                   JabberLog( "SSL set fd failed" );
                                   pfn_SSL_free( ssl );
                }    
            }    
        }
 
              if ( !info->ssl )
        {
                     if ( info->type == JABBER_SESSION_NORMAL )
            {
                            oldStatus = jabberStatus;
                            jabberStatus = ID_STATUS_OFFLINE;
                            JSendBroadcast( NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, ( HANDLE ) oldStatus, jabberStatus );
                            JSendBroadcast( NULL, ACKTYPE_LOGIN, ACKRESULT_FAILED, NULL, LOGINERR_NONETWORK );
                            if ( jabberThreadInfo == info )
                                   jabberThreadInfo = NULL;
                     }
                     else if ( info->type == JABBER_SESSION_REGISTER )
            {
                            SendMessage( info->reg_hwndDlg, WM_JABBER_REGDLG_UPDATE, 100, ( LPARAM )TranslateT( "Error: Cannot connect to the server" ));
                     }
                     mir_free( buffer );
                     if ( !hLibSSL )
                            MessageBox( NULL, TranslateT( "The connection requires an OpenSSL library, which is not installed." ), TranslateT( "Jabber Connection Error" ), MB_OK|MB_ICONSTOP|MB_SETFOREGROUND );
                     JabberLog( "Thread ended, SSL connection failed" );
                     goto LBL_Exit;
        }    
    }
 
       // User may change status to OFFLINE while we are connecting above
       if ( jabberDesiredStatus != ID_STATUS_OFFLINE || info->type == JABBER_SESSION_REGISTER )
    {
 
              if ( info->type == JABBER_SESSION_NORMAL )
        {
                     jabberConnected = TRUE;
                     int len = _tcslen( info->username ) + strlen( info->server )+1;
                     jabberJID = ( TCHAR* )mir_alloc( sizeof( TCHAR)*( len+1 ));
                     mir_sntprintf( jabberJID, len+1, _T("%s@") _T(TCHAR_STR_PARAM), info->username, info->server );
                     if ( JGetByte( "KeepAlive", 1 ))
                            jabberSendKeepAlive = TRUE;
                     else
                            jabberSendKeepAlive = FALSE;
            //连接建立以后创建一个保持活跃的线程
                     mir_forkthread(( pThreadFunc )JabberKeepAliveThread, info );
              }
 
              xmlStreamInitializeNow( info );
 
              JabberLog( "Entering main recv loop" );
              datalen = 0;
 
        //zhangcong//main recv loop, 出现异常时,将break loop
              for ( ;; )
        {
                     int recvResult = info->recv( buffer+datalen, jabberNetworkBufferSize-datalen);
            int bytesParsed;
                     JabberLog( "recvResult = %d", recvResult );
                     if ( recvResult <= 0 )
                            break;
                     datalen += recvResult;
 
                     buffer[datalen] = '/0';
                     if ( info->ssl && DBGetContactSettingByte( NULL, "Netlib", "DumpRecv", TRUE ) == TRUE )
            {
                            // Emulate netlib log feature for SSL connection
                            char* szLogBuffer = ( char* )mir_alloc( recvResult+128 );
                            if ( szLogBuffer != NULL )
                {
                                   strcpy( szLogBuffer, "( SSL ) Data received/n" );
                                   memcpy( szLogBuffer+strlen( szLogBuffer ), buffer+datalen-recvResult, recvResult+1 /* also copy /0 */ );
                                   Netlib_Logf( hNetlibUser, "%s", szLogBuffer );   // %s to protect against when fmt tokens are in szLogBuffer causing crash
                                   mir_free( szLogBuffer );
                }    
            }
 
            //XmlParse接收到的数据
                     bytesParsed = JabberXmlParse( &xmlState, buffer );
                     JabberLog( "bytesParsed = %d", bytesParsed );
                     if ( bytesParsed > 0 )
            {
                            if ( bytesParsed < datalen )
                                   memmove( buffer, buffer+bytesParsed, datalen-bytesParsed );
                            datalen -= bytesParsed;
                     }
                     else if ( datalen == jabberNetworkBufferSize )
            {
                //如果缓冲区已满, 扩充缓冲区
                            jabberNetworkBufferSize += 65536;
                            JabberLog( "Increasing network buffer size to %d", jabberNetworkBufferSize );
                            if (( buffer=( char* )mir_realloc( buffer, jabberNetworkBufferSize+1 )) == NULL ) {
                                   JabberLog( "Cannot reallocate more network buffer, go offline now" );
                                   break;
                }    
            }
                     else
            {
                JabberLog( "Unknown state: bytesParsed=%d, datalen=%d, jabberNetworkBufferSize=%d", bytesParsed, datalen, jabberNetworkBufferSize );
            }
 
                     if (xmlStreamToBeInitialized)
                xmlStreamInitializeNow(info);
              }
 
        //出现异常后, 跳出main recv loop, 清理现场,设置状态
 
              JabberXmlDestroyState(&xmlState);
 
              if ( info->type == JABBER_SESSION_NORMAL )
        {
                     jabberOnline = FALSE;
                     jabberConnected = FALSE;
                     JabberEnableMenuItems( FALSE );
                     if ( hwndJabberChangePassword )
            {
                            //DestroyWindow( hwndJabberChangePassword );
                            // Since this is a different thread, simulate the click on the cancel button instead
                            SendMessage( hwndJabberChangePassword, WM_COMMAND, MAKEWORD( IDCANCEL, 0 ), 0 );
                     }
 
                     if ( jabberChatDllPresent )
                            QueueUserAPC( JabberOfflineChatWindows, hMainThread, 0 );
 
                     JabberListRemoveList( LIST_CHATROOM );
                     if ( hwndJabberAgents )
                            SendMessage( hwndJabberAgents, WM_JABBER_CHECK_ONLINE, 0, 0 );
                     if ( hwndJabberGroupchat )
                            SendMessage( hwndJabberGroupchat, WM_JABBER_CHECK_ONLINE, 0, 0 );
                     if ( hwndJabberJoinGroupchat )
                            SendMessage( hwndJabberJoinGroupchat, WM_JABBER_CHECK_ONLINE, 0, 0 );
 
                     // Set status to offline
                     oldStatus = jabberStatus;
                     jabberStatus = ID_STATUS_OFFLINE;
                     JSendBroadcast( NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, ( HANDLE ) oldStatus, jabberStatus );
 
                     // Set all contacts to offline
                     HANDLE hContact = ( HANDLE ) JCallService( MS_DB_CONTACT_FINDFIRST, 0, 0 );
                     while ( hContact != NULL )
            {
                            if ( !lstrcmpA(( char* )JCallService( MS_PROTO_GETCONTACTBASEPROTO, ( WPARAM ) hContact, 0 ), jabberProtoName ))
                                   if ( JGetWord( hContact, "Status", ID_STATUS_OFFLINE ) != ID_STATUS_OFFLINE )
                                          JSetWord( hContact, "Status", ID_STATUS_OFFLINE );
 
                            hContact = ( HANDLE ) JCallService( MS_DB_CONTACT_FINDNEXT, ( WPARAM ) hContact, 0 );
                     }
 
                     mir_free( jabberJID );
                     jabberJID = NULL;
                     jabberLoggedInTime = 0;
                     JabberListWipe();
                     if ( hwndJabberAgents )
            {
                            SendMessage( hwndJabberAgents, WM_JABBER_AGENT_REFRESH, 0, ( LPARAM )"" );
                            SendMessage( hwndJabberAgents, WM_JABBER_TRANSPORT_REFRESH, 0, 0 );
                     }
                     if ( hwndJabberVcard )
                            SendMessage( hwndJabberVcard, WM_JABBER_CHECK_ONLINE, 0, 0 );
              }
              else if ( info->type==JABBER_SESSION_REGISTER && !info->reg_done )
        {
                     SendMessage( info->reg_hwndDlg, WM_JABBER_REGDLG_UPDATE, 100, ( LPARAM )TranslateT( "Error: Connection lost" ));
        }
       }
       else if ( info->type == JABBER_SESSION_NORMAL )
    {
              oldStatus = jabberStatus;
              jabberStatus = ID_STATUS_OFFLINE;
              JSendBroadcast( NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, ( HANDLE ) oldStatus, jabberStatus );
       }
 
       JabberLog( "Thread ended: type=%d server='%s'", info->type, info->server );
 
       if ( info->type==JABBER_SESSION_NORMAL && jabberThreadInfo==info )
    {
              if ( streamId ) mir_free( streamId );
              streamId = NULL;
              jabberThreadInfo = NULL;
       }
 
       mir_free( buffer );
       JabberLog( "Exiting ServerThread" );
       goto LBL_Exit;
}
 
JabberRecvMessage
int JabberRecvMessage( WPARAM wParam, LPARAM lParam )
{
       CCSDATA *ccs = ( CCSDATA* )lParam;
       PROTORECVEVENT *pre = ( PROTORECVEVENT* )ccs->lParam;
 
       DBEVENTINFO dbei = { 0 };
       dbei.cbSize = sizeof( dbei );
       dbei.szModule = jabberProtoName;
       dbei.timestamp = pre->timestamp;
       dbei.flags = pre->flags&PREF_CREATEREAD?DBEF_READ:0;
       dbei.eventType = EVENTTYPE_MESSAGE;
       dbei.cbBlob = strlen( pre->szMessage ) + 1;
       if ( pre->flags & PREF_UNICODE )
              dbei.cbBlob *= ( sizeof( wchar_t )+1 );
 
       dbei.pBlob = ( PBYTE ) pre->szMessage;
       JCallService( MS_DB_EVENT_ADD, ( WPARAM ) ccs->hContact, ( LPARAM )&dbei );
       return 0;
}
 
程序猿凯撒
关注
专栏目录
Linux驱动开发: 网络设备驱动开发
09-01 4996
Linux内核版本:3.5 一、Linux下网络相关命令 1.1 ifconfig命令：设置网卡IP地址 功能 ifconfig用于查看和更改网络接口的地址和参数，包括IP地址、网络掩码、广播地址，使用权限是超级用户。 语法：fconfig -interface [options] address 主要参数 -interface 指定的网络接口名，如eth0和eth1。 up 激活指定的网络接口卡。 ..
jabber-registration-tool:Jabber 注册工具
06-03
Jabber 注册工具 Jabber 注册工具(JRT) 是一个 PHP：超文本预处理器 (PHP) 脚本，允许通过 Web 在 Jabber 服务器上注册 Jabber ID (JID)。 它是在 GNU 通用公共许可证 (GPL) 下分发的。 Jabber 注册工具 (JRT) 的原作者是Rene SC Bartosh ( ) 。 由于这个项目不再由其原作者维护，我决定继续它并提供一些小的更改。 原始源代码可以在找到 要解决的问题： Xmpp 服务器通常与 DNS SRV 记录一起使用，以便客户端发现服务、主机名等。我面临的问题是，如果一个 xmpp 服务器提供多个虚拟主机，虚拟主机名称为 **example.org** （*为了提供像 user@example.org* 这样的 jid）和一个不同于 example.org 的主机名（例如 **xmpp.example.org
注销登录(Session清空)
weixin_44541076的博客
07-18 2289
分享一下自己所学习到的一个功能实现，通过Session的清空来实现注销用户登录。 首先，在控制器中写好清空Session的方法。 Emmm,就一句代码，极其精简。 方法写好之后就来到视图层上调用方法。 写一个Ajax请求调用控制器中的方法。 一般这种情况下用的都是confirm提示框比较多吧，起码让用户确认一下在退出这样子会好点。 大概就是这样子了，一个注销用户登录功能的实现，也没有什么特别...
用户登录和注销
Orange_soda的博客
11-18 4705
这节我主要写用户的登录和注销，动作分解为 登录界面登录->跳转到主页，并用户信息发生改变->注销用户，用户信息改变 一.登录用户 1.网页设置 注意这里的type=“passworld”，是针对密码的 2.login函数设置 def login(req): username=req.POST.get("username") password=req.POST.
Jabber 注册一个新用户的流程(JabberD + gloox)
迅影
05-22 9518
从网络实际发送,接收到的包来分析Jabber协议中注册一个新用户的过程例子服务器所用的是 JabberD2 S7版 客户端是 gloox 0.8版的注册测试程序用其它的服务器和客户端,可能会有所不同,但大体上应该是一样的C->S 001xmlns=jabber:clientxmlns:stream=http://etherx.jabber.org/streams xml:lang=en
0003.用户登录和注销
akmissxt的博客
01-26 559
用户登录流程：用户输入-->页面校验数据后提交表单-->判断是否已经登录-->判断输入是否合法-->查询数据库是否有对应用户-->返回登录结果 先对页面表单提交地址和方式进行调整，输入项添加required必填项属性。 User Name: Password: 页面引入struts
收发Jabber消息流程
hurtmanzc的专栏
09-25 4433
  1.   聊天对话框基本信息:1)        对话框模板:  IDD_MSG2)        窗口过程:  DlgProcMessage3)        “发送”按钮: IDOK 在聊天对话框初始化的时候关于该联系人所用协议等信息已经做为该窗口的用户数据设置好了,用到的时候只要以GWL_USERDATA 为参数调用GetWindowLong就可以得到该用户数据的
Android之基于XMPP协议即时通讯软件(二) - way - 博客频道 - CSDN1
08-04
- **用户管理模块**：处理用户注册、登录、注销等操作。 - **消息传输模块**：负责消息的发送、接收和存储，包括文本、图片、文件等多种类型。 - **会话管理模块**：管理用户间的会话，包括一对一聊天和群组聊天...
Android应用源码之【仿微信即时聊天】xmpp4Android 第一期.zip
12-04
退出时，客户端需要发送注销请求，告知服务器用户已下线。 3. **好友列表和联系人管理**：在仿微信的应用中，好友列表是必不可少的。这部分源码可能包含了获取和更新联系人列表的逻辑，以及添加、删除和搜索好友的...
xmpp协议下载
07-27
3. **会话管理**（Session Management）：处理登录、注销以及心跳保活等任务。 4. **消息与事件处理**：支持发送和接收各种类型的XMPP消息，如文本、HTML、文件等，并处理相关事件。 在开发XMPP应用时，开发者通常...
cisco jabber
10-23
cisco jabber下载,
jabber概述
04-02
Jabber是一个由开源社区发起并领导开发的即时消息和在线状态的系统。Jabber系统和其它即时消息（IM）服务的一个功能上的差别在于Jabber拥有开放的XML协议。在保持Jabber1.0版本有关消息核心以及在线状态的协议的基础上，增加了一些必要的扩展。本文档将对Jabber服务器1.4版的Jabber协议进行介绍
Jabber 11.0.1 for Andorid
04-29
Cisco Jabber 11.0.1 for Andorid, 安卓系统通用，Cisco出品的即时聊天软件。
安装和配置jabber服务器教程
10-15
安装和配置jabber服务器教程 安装和配置jabber服务器教程 安装和配置jabber服务器教程
【用户登录与注销】你真的懂登录吗？
最新发布
仰望-星空~~的博客
07-27 740
我记得我刚刚接触数据库 MySQL 的时候，老师最常让我们做的作业就是学生管理系统的注册和登录。当时我还没学过MyBatis,也不知道有 Mybatis-Plus ，只会一点 JDBC ,连代码都不记得，需要网上搜寻一遍。那时候，我以为的注册登录自然就是将用户数据写入数据库，然后将查询数据和输入的数据进行比对实现登录。不过，我越学到后面越发现注册登录并没有我想的这么简单！举个例子：用户从一个网站登录，我们首先需要校验他是否注册过；
jabber协议如何注册一个用户
大米文子
07-01 1549
#jabber协议中如何注册一个用户？首先要与服务器建立一个连接, 在完成TLS握手之后就可以进行注册了,为什么不需要SASL握手呢?因为SASL握手只针对已经注册的用户在登陆服务器的时候使用.(修改密码和删除用户的时候需要SASL握手)下面以openfire作为服务器，注册一个用户的过程如下:(假设已经完成了TLS握手)1. ( C-&gt;S ) &lt;stream:stream     t...
计算机账户注销重新登录,win10系统注销账户切换账号登录的方法
热门推荐
weixin_42515687的博客
07-26 1万+
相信有很多用户在使用win10系统的电脑时经常需要切换账号进行登录，使用多个账号操作电脑的话可以对账号的一些权限进行限制，根据最高管理员对这些账户权限的分配可以限制某个账户对电脑进行某些操作，于是用户在使用的过程中就会遇到需要注销账号以及切换账号登录的问题了，一些对系统操作不熟悉的用户还不知道要怎么切换账号登录，那么接下来小编就跟大家分享一下win10系统中切换账号登录的具体操作方法吧，感兴趣的朋...
A. Jabber ID
chaideyipi
04-21 460
A. Jabber IDtime limit per test0.5 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputJabber ID on the national Berland service ?Babber? has a form @[/resource], where — i
Ejabber2.1.3 配置admin注册用户 ，禁止普通用户注册
weixin_33711647的博客
10-13 109
打开：ejaberred.cfg修改下面这两行 ，其中 register_from 为新加入%% To disable in-band registration, replace 'allow' with 'deny'. {access, register, [{allow, admin}]}. {access, register_from, [{allow, admin}]...
Cisco Jabber Lab手册：版本9.6
- **Cisco Jabber-Config.xml**：这是一个XML文件，包含Jabber客户端的详细配置信息，如设备注册、服务发现和功能启用。 - **目录同步**：确保CUCM与Jabber之间的联系人列表同步，以便用户可以查找和呼叫其他用户。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值