基于Mozilla Thunderbird的扩展开发（八）---进程间通信之Socket篇（续）

Mozilla扩展系列链接： 1，浅谈基于Mozilla Thunderbird的扩展开发 2，基于Mozilla平台的扩展开发（续）----XPCOM组件篇 3，基于Mozilla Thunderbird的扩展开发（三）---如何获取邮件的完整信息 4，基于Mozilla Thunderbird的扩展开发（四）---修改源代码实现自动保存附件 5，基于Mozilla Thunderbird的扩展开发（五）---进程间通信之Socket篇（上） 6，基于Mozilla Thunderbird的扩展开发（六）---进程间通信之Socket篇（下） 7, 基于Mozilla Thunderbird的扩展开发（七）---工欲善其事，必先利其器

最近遇到这样一个需求：在我们的MFC程序中控制Thunderbird。拿到这个奇怪的需求后，有了这么几个想法：1）用全局钩子试着勾住Thunderbird，可细想好像不对。2）用spy++探查点击Thunderbird的各个菜单，按钮时触发的事件，总归是win32平台上跑的程序，归根到底还是事件触发，从理论上说应该是可以在我们自己的MFC程序中模拟目标程序中的各个事件触发。

但接触到Mozilla的socket方面的知识后，放弃了上面的想法，改用socket通信来实现此需求。一来Thunderbird源代码可以自行修改，因此可以加入一些代码使之成为一个类似HTTP服务器的服务器端程序，二来使用socket进行连接与语言无关，因此C++的程序可以和javascript的程序完成通信，但缺点也很明显，要占用端口，只涉及到本地机器的通信却使用了socket这样的网络通信机制。

先来介绍下完成这个功能用到的基本知识：由于输入流基接口nsIInputStream没有提供任何从javascript中读取数据的方法，而只能在C++中读取，因此我们必须使用一个可脚本化的输入流来对其进行包装，这个可脚本化的输入流实现了nsIScriptableInputStream接口。

当然也可以使用其他流类型，比如为了读取二进制数据，我们可以使用nsIBinaryInputStream，反正在javascript中，你总得以其他形式的流来包装基流。

在Mozilla中，网络数据的读和写是在一个单独的线程中进行的，从socket中读数据是异步的，这就意味着只要socket中有数据存在，就在后台读取数据，而程序会收到数据可读的通知信息，这就意味着我们需要创建一个监听者来监听这个信息。

对于异步读取数据，我们还需要创建一个输入流Pump,之所以Mozilla选择“泵”这个名称是因为当有数据存在时它就发送小块的数据给监听者。这个Pump实现了nsIInputStreamPump接口，这个接口继承自nsIRequest,后者提供了暂停连接和特定的缓存行为（这些一般的socket程序用不上，但像HTTP这样构建在socket上的高层次应用会用得上的）。

pump.asyncRead(dataListener,null);

     asyncRead函数用来给Pump对象设置一个监听者，当有数据到来或连接关闭时，监听者就会被调用。监听者对象应该实现nsIStreamListener接口，这个接口有一个方法onDataAvailable,当有额外数据可读时就会被调用。此接口继承自nsIRequestObserver，这个接口有两个方法，onStartRequest，onStopRequest，这两个方法在输入流的开始和结束时分别被调用，因此这3个方法都应该实现。

下面是客户端代码，使用最简单的阻塞式TCP连接：

void CClientTestDlg::OnSend() 
{//发送按钮
    UpdateData();
    if(str.IsEmpty())
    {
        list.InsertString(0,"发送的字符串不能为空。");
        return;
    }
    //strcpy(msg.msg,(LPCTSTR)str);
    char szText[1024];
    strcpy(szText,(LPCTSTR)str);
    SOCKET socket = ::socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    if(socket==INVALID_SOCKET)
    {
        list.InsertString(0,"创建socket发生错误。");
        return;
    }
    SOCKADDR_IN servAddr;
    servAddr.sin_family = AF_INET;
    servAddr.sin_port = htons(25501);
    servAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    if(::connect(socket,(sockaddr*)&servAddr,sizeof(servAddr))==-1)
    {
        list.InsertString(0,"连接服务器发生错误。");
        return;
    }
    if(::send(socket,szText,strlen(szText),0) == SOCKET_ERROR)//    recv(ServerSocket,buf,sizeof(buf),0);
    {
        list.InsertString(0,"发送数据发生错误。");
        return;
    }
    int bytesRecv = SOCKET_ERROR;
    char buffer[1024];
    memset(buffer,0,1024);
    bytesRecv = recv( socket, buffer, 1024, 0 );
    DWORD dwerr = WSAGetLastError();
    CString str;
    str.Format("%s",buffer);
    list.InsertString(0,str);
    ::closesocket(socket);
}

服务器端代码，通过修改Thunderbird源代码，使之成为一个类似HTTP服务器的服务器端

 

//***************************************************************************
//Author: phinecos
//Date : 2008/5/19
//Description:服务器监听对象
//Contact:phinecos@163.com
//***************************************************************************
//服务器端对象

const CI = Components.interfaces, CC = Components.classes, CR = Components.results;

var gServer = null;//服务器对象
var gUtility = null;//工具类对象
//var gConnection = null;//客户端连接对象

function tBirdBiffServerOnLoad()
{//启动监听服务器
    
    try
    {
        gUtility = new tBirdBiffUtility();//新建日志对象
        gUtility.initialize();
          gUtility.log("tBirdBiffServerUi.tBirdBiffServerOnLoad", "Thunderbird biff server loaded");

        gServer = new tBirdBiffServer();//新建服务器对象
        gServer.initialize();//初始化服务器端
        gUtility.log("tBirdBiffServerOnLoad","start server");
    }
    catch(err)
    {
          gUtility.log("tBirdBiffServerOnLoad","start server failed");
    }
}

function tBirdBiffServerOnClose()
{//关闭服务器    
    gUtility.log("tBirdBiffServerOnClose","close server");
    gServer.finalize();
    gServer = null;
    gUtility = null;
}

function tBirdBiffServer()
{
  this.serverSocket = null;//服务器端socket
  this.port = null;//服务器端口
  this.initialized = false;
  gUtility.log("tBirdBiffServer constructor","construct ok");
}

tBirdBiffServer.prototype =
{
  getServerSocket: function()
  {//创建服务器端socket
    this.serverSocket = CC["@mozilla.org/network/server-socket;1"].createInstance(CI.nsIServerSocket);
    if(!this.serverSocket)
    {
      gUtility.log("tBirdBiffServer.getServerSocket","Unable to get a server socket");
    }
    else
    {
      try
      {
        this.serverSocket.init(this.port, false, -1);//初始化socket,绑定到端口port上
        this.serverSocket.asyncListen(tBirdBiffServerSocketListener);//开始异步监听
        gUtility.log("tBirdBiffServer.getServerSocket","Server socket established");
      }
      catch(e)
      {
         gUtility.log("tBirdBiffServer.getServerSocket, Server socket established error");
         this.serverSocket = null;
      }
    }
  },

  closeServerSocket: function()
  {//关闭服务器端socket
    if(!this.serverSocket)
    {
      this.serverSocket.close(null);
      this.serverSocket = null;
    }
  },

  initialize: function()
  {
    if(this.initialized)
    {
      return;
    }
    
    this.port = 25501;//获取端口号
    gUtility.log("tBirdBiffServer.initialize","port is: "+this.port);
    this.getServerSocket();//创建服务器端socket
    this.initialized = true;
       gUtility.log("tBirdBiffServer.initialize","initialize ok!");
  },
  finalize: function()
  {//退出程序
    if(!this.initialized)
    {
      return;
    }
    this.closeServerSocket();//关闭服务器端socket
    gUtility.log("tBirdBiffServer.finalize","server Finalized");
  },

}
  var listener = 
  {
    finished : function(data)
    {//数据读取完毕
      ParseCommand(data);//解析命令字
    }
  }

const tBirdBiffServerSocketListener =
{
  onSocketAccepted: function(serverSocket, clientSocket)
  {//接受来自客户端的socket请求
     gUtility.log("tBirdBiffServerSocketListener.onSocketAccepted","Got a connection from: " + clientSocket.host + ":" + clientSocket.port);
     var outputData = "Ok,server get your command";
     var outstream = clientSocket.openOutputStream(0,0,0);
     outstream.write(outputData,outputData.length);
     try
     {
         //打开输入流
         var stream = clientSocket.openInputStream(0,0,0);
         var instream = Components.classes["@mozilla.org/scriptableinputstream;1"].createInstance(Components.interfaces.nsIScriptableInputStream);
         instream.init(stream);
         
        var dataListener = 
        {
          data : "",//来自客户端的数据
          onStartRequest: function(request, context){},
          onStopRequest: function(request, context, status){
            instream.close();
            outstream.close();
            listener.finished(this.data);
          },
          onDataAvailable: function(request, context, inputStream, offset, count){
            this.data += instream.read(count);
          },
        };
        var pump = Components.classes["@mozilla.org/network/input-stream-pump;1"].createInstance(Components.interfaces.nsIInputStreamPump);
        pump.init(stream, -1, -1, 0, 0, false);
        pump.asyncRead(dataListener,null);
    }
    catch(err)
    {
        gUtility.log("tBirdBiffServerConnection.setSocket",e);
           return false;
    }
  },
  onStopListening: function(serverSocket, status)
  {//服务器端停止监听
    gUtility.log("tBirdBiffServerSocketListener.onStopListening","Server socket has stopped listening");
  }
}

 

Reference

1, http://www.xulplanet.com/tutorials/mozsdk/sockets.php

2, 基于Mozilla Thunderbird的扩展开发（五）---进程间通信之Socket篇（上）

3, 基于Mozilla Thunderbird的扩展开发（六）---进程间通信之Socket篇（下）