去掉windows脚本中的中文，解决windows平台下启动失败的问题

This reverts commit ab8ae9d0c9.

.github/ISSUE_TEMPLATE.md

@@ -11,7 +11,13 @@
 你认为正确的表现应该是什么样的。
 
 #### 补充条件
-是否是毕现的，还是偶现的？是否只有在特殊的网络/设备/平台上出现，还是所有的都出现。还有您用的版本是什么时候的，是不是最新版
+是否是必现的，还是偶现的？是否只有在特殊的网络/设备/平台上出现，还是所有的都出现。还有您用的版本是什么时候的，是不是最新版
 
 #### demo对比结果
 请用demo对比测试，demo上是什么状态。
+
+#### 检索已有问题
+除了可以检索已有issue外，还可以去野火论坛查找已有问题，论坛地址为 https://bbs.wildfirechat.cn
+
+#### star 我们
+给我们点个star，可以及时接收到我们回复信息，另外也是对我们支持人员辛苦工作的认可，激励我们更好更快地为大家服务。

README.md

@@ -1,85 +1,230 @@
-## 野火IM解决方案
+# 野火IM解决方案
+野火IM是专业级的即时通讯和实时音视频整体解决方案，由北京野火无限网络科技有限公司维护和支持。
 
-野火IM是专业级即时通讯和实时音视频整体解决方案，由北京野火无限网络科技有限公司维护和支持。
+## 功能特性
+* 极致地硬件利用率，IM服务最低128M内存即可运行，上不封顶。
+* 协议先进，采用MQTT+Protobuf组合，流量和性能极致优化。
+* 性能强大，专业版IM服务支持百万在线和集群部署，业内顶尖性能水平，详情参考野火性能报告。
+* 部署运维简单，依赖服务少，稍加配置一键启动。
+* 安全加密。网络连接AES加密。客户端数据库SqlCipher加密。安全无小事。
+* 全平台客户端，支持Android、iOS、Web、小程序、UniApp、Flutter、Windows、Mac OS、Linux等所有常见平台。
+* 四端同时在线（移动端，pc端，web端和小程序端），数据和状态多端完美同步。
+* 支持国产化。支持国产化操作系统、国产化芯片和国产操作系统。支持国密加密。
+* 客户端使用微信[mars](https://github.com/tencent/mars)连接库，野火IM可能是最适应中国网络国情的即时通讯服务。
+* 支持加速点加速，即可用于全球应用，也可用于政企内外双网复杂的网络环境。
+* 支持阅读回执和在线状态功能，适用于办公环境。
+* 音视频多种解决方案，丰俭由人，可自由选择。
+* 高级音视频功能强大，支持9人以上的群组视频通话，支持1080P视频，支持会议模式，支持百人以上会议，支持服务器端录制。
+* 全私有部署，可不依赖任何第三方服务，完全内网部署。
+* 功能齐全，涵盖所有常见即时通讯功能。另外具有强大的可扩展能力。代码开源率高，二次开发简单。
+* 结构设计合理，客户端分功能库、UI库和应用三层。应用成熟完善，开箱即用，也可把SDK嵌入其它应用。
+* 拥有应用开放平台，可以开发和创建自建应用，扩展您的工作台。
+* API丰富，方便与其它服务系统的对接。
+* 拥有机器人和公众号功能。
+* 社区版IM服务和移动端免费商用，可以免费构建出完备的移动互联网应用。
+* 收费项目非常便宜，野火独有的试用模式，可以先部署到客户环境试用6个月，试用满意后再购买，避免上当受骗。
+* 技术支持专业和高效，核心研发人员及时处理issue和论坛回复。
 
-主要特性有：私有部署安全可靠，性能强大，功能齐全，全平台支持，开源率高，部署运维简单，二次开发友好，方便与第三方系统对接或者嵌入现有系统中。详细情况请参考[在线文档](https://docs.wildfirechat.cn)。
+## 野火开源项目
+主要包括以下项目：
 
-主要包括一下项目：
+| [GitHub仓库](https://github.com/wildfirechat)      | [码云仓库](https://gitee.com/wfchat)        | 说明                                                                                      
+| ------------------------------------------------------------ | ----------------------------------------------------- | --------------------------------------------------------------------------
+| [im-server](https://github.com/wildfirechat/im-server)       | [im-server](https://gitee.com/wfchat/im-server)          | 野火社区版IM服务，野火IM的核心服务，处理所有IM相关业务。  |
+| [app-server](https://github.com/wildfirechat/app-server)     | [app-server](https://gitee.com/wfchat/app-server)     | Demo应用服务，模拟客户的应用服登陆处理逻辑及部分二次开发示例。 |
+| [robot_server](https://github.com/wildfirechat/robot_server) | [robot_server](https://gitee.com/wfchat/robot_server) | 机器人服务，演示野火机器人对接其它系统的方法。 |
+| [push_server](https://github.com/wildfirechat/push_server)   | [push_server](https://gitee.com/wfchat/push_server)   | 推送服务器，可以对接所有的系统厂商推送服务或者第三方推送服务。 |
+| [wf-minio](https://github.com/wildfirechat/WF-minio)   | [wf-minio](https://gitee.com/wfchat/WF-minio)   | 私有对象存储服务，用来支持野火IM专业版的文件存储。 |
+| [wf-janus](https://github.com/wildfirechat/wf-janus  )   | [wf-janus](https://gitee.com/wfchat/wf-janus  )   | 高级音视频媒体服务。 |
+| [open-platform](https://github.com/wildfirechat/open-platform)   | [open-platform](https://gitee.com/wfchat/open-platform)   | 野火开放平台服务。  |
+| [daily-report](https://github.com/wildfirechat/daily-report)   | [daily-report](https://github.com/wildfirechat/daily-report)   | 野火开放平台日报 demo服务。 |
+| [channel-platform](https://github.com/wildfirechat/channel-platform)   | [channel-platform](https://gitee.com/wfchat/channel-platform)   | 野火频道(公众号)平台服务。  |
+| [organization-platform](https://github.com/wildfirechat/organization-platform)   | [organization-platform](https://gitee.com/wfchat/organization-platform)   | 野火组织通讯录服务。  |
+| [android-chat](https://github.com/wildfirechat/android-chat) | [android-chat](https://gitee.com/wfchat/android-chat) | 野火IM Android SDK源码和App源码。 |
+| [ios-chat](https://github.com/wildfirechat/ios-chat)         | [ios-chat](https://gitee.com/wfchat/ios-chat)         | 野火IM iOS SDK源码和App源码。|
+| [pc-chat](https://github.com/wildfirechat/vue-pc-chat)       | [pc-chat](https://gitee.com/wfchat/vue-pc-chat)       | 基于[Electron](https://electronjs.org/)的PC 端，支持Windows、Mac、Linux（包括国产化linux系统和CPU）。   |
+| [web-chat](https://github.com/wildfirechat/vue-chat)         | [web-chat](https://gitee.com/wfchat/vue-chat)         | 野火IM Web 端, [体验地址](https://web.wildfirechat.cn)。  |
+| [wx-chat](https://github.com/wildfirechat/wx-chat)           | [wx-chat](https://gitee.com/wfchat/wx-chat)           | 小程序平台的Demo(支持微信、百度、阿里、字节、QQ 等小程序平台)。  |
+| [uni-chat](https://github.com/wildfirechat/uni-chat)           | [uni-chat](https://gitee.com/wfchat/uni-chat)           | UniApp平台移动端应用(使用原生插件)。   |
+| [uni-wfc-client](https://github.com/wildfirechat/uni-wfc-client)           | [uni-wfc-client](https://gitee.com/wfchat/uni-wfc-client)           | UniApp平台原生插件。已[商店](https://ext.dcloud.net.cn/plugin?id=7895)上架   |
+| [wfc_flutter_plugins](https://github.com/wildfirechat/wfc_flutter_plugins)           | [flutter_imclient](https://gitee.com/wfchat/wfc_flutter_plugins)           | Flutter平台原生插件，支持IM和音视频通话。   |
+| [docs](https://github.com/wildfirechat/docs)                 | [docs](https://gitee.com/wfchat/docs)                 | 野火IM相关文档，包含设计、概念、开发、使用说明，[在线查看](https://docs.wildfirechat.cn/)。 |
 
-| [GitHub仓库地址(主站)](https://github.com/wildfirechat)      | [码云仓库地址(镜像)](https://gitee.com/wfchat)        | 说明                                                                                      | 备注                                           |
-| ------------------------------------------------------------ | ----------------------------------------------------- | ----------------------------------------------------------------------------------------- | ---------------------------------------------- |
-| [android-chat](https://github.com/wildfirechat/android-chat) | [android-chat](https://gitee.com/wfchat/android-chat) | 野火IM Android SDK源码和App源码                                                           | 可以很方便地进行二次开发，或集成到现有应用当中 |
-| [ios-chat](https://github.com/wildfirechat/ios-chat)         | [ios-chat](https://gitee.com/wfchat/ios-chat)         | 野火IM iOS SDK源码和App源码                                                               | 可以很方便地进行二次开发，或集成到现有应用当中 |
-| [pc-chat](https://github.com/wildfirechat/pc-chat)           | [pc-chat](https://gitee.com/wfchat/pc-chat)           | 基于[Electron](https://electronjs.org/)开发的PC平台应用                                   |                                                |
-| [web-chat](https://github.com/wildfirechat/web-chat)         | [web-chat](https://gitee.com/wfchat/web-chat)         | Web平台的Demo, [体验地址](http://web.wildfirechat.cn)                                     |                                                |
-| [wx-chat](https://github.com/wildfirechat/wx-chat)           | [wx-chat](https://gitee.com/wfchat/wx-chat)           | 微信小程序平台的Demo                                                                      |                                                |
-| [server](https://github.com/wildfirechat/server)             | [server](https://gitee.com/wfchat/server)             | IM server                                                                                 |                                                |
-| [app server](https://github.com/wildfirechat/app_server)     | [app server](https://gitee.com/wfchat/app_server)     | 应用服务端                                                                                |                                                |
-| [robot_server](https://github.com/wildfirechat/robot_server) | [robot_server](https://gitee.com/wfchat/robot_server) | 机器人服务端                                                                              |                                                |
-| [push_server](https://github.com/wildfirechat/push_server)   | [push_server](https://gitee.com/wfchat/push_server)   | 推送服务器                                                                                |                                                |
-| [docs](https://github.com/wildfirechat/docs)                 | [docs](https://gitee.com/wfchat/docs)                 | 野火IM相关文档，包含设计、概念、开发、使用说明，[在线查看](https://docs.wildfirechat.cn/) |                                                |  |
+## 野火开发文档
+[在线文档](https://docs.wildfirechat.cn/)
 
+## 野火性能测试报告及测试方法
+[Github](https://github.com/wildfirechat/Performance_Test), [码云](https://gitee.com/wfchat/Performance_Test)。
 
-# server
-本工程为野火IM 社区版IM服务软件。野火IM作为一个通用的即时通讯解决方案，既可以直接使用，也可以集成到各种应用中。
-
-
-开发一套IM系统真的很艰辛，请路过的朋友们给点个star，支持我们坚持下去🙏🙏🙏🙏🙏
-
-### 联系我们
-
-> 商务合作请优先采用邮箱和我们联系。技术问题请到[野火IM论坛](http://bbs.wildfirechat.cn/)发帖交流
-
-1. heavyrain.lee  邮箱: heavyrain.lee@wildfirechat.cn  微信：wildfirechat
-2. imndx  邮箱: imndx@wildfirechat.cn  微信：wfchat
-
-### 问题交流
-
-1. 如果大家发现bug，请在GitHub提issue
-2. 其他问题，请到[野火IM论坛](http://bbs.wildfirechat.cn/)进行交流学习
-3. 微信公众号
-
-<img src="http://static.wildfirechat.cn/wx_wfc_qrcode.jpg" width = 50% height = 50% />
-
-> 强烈建议关注我们的公众号。我们有新版本发布或者有重大更新会通过公众号通知大家，另外我们也会不定期的发布一些关于野火IM的技术介绍。
-
-#### 体验Demo
-我们提供了体验demo，请使用微信扫码下载安装体验
+## 野火Demo
+请使用微信扫码下载安装体验野火IM移动客户端
 
 ![野火IM](http://static.wildfirechat.cn/download_qrcode.png)
 
-#### 应用截图
-![ios-demo](http://static.wildfirechat.cn/ios-demo.gif)
+Web客户端点击[这里](https://web.wildfirechat.cn)
 
-<img src="http://static.wildfirechat.cn/ios-message-view.png" width = 50% height = 50% />
+PC客户端点[这里](https://github.com/wildfirechat/vue-pc-chat/releases)下载安装。
 
-<img src="http://static.wildfirechat.cn/ios-contact-view.png" width = 50% height = 50% />
+小程序客户端请用微信扫码
 
-<img src="http://static.wildfirechat.cn/ios-discover-view.png" width = 50% height = 50% />
+![野火IM](http://static.wildfirechat.net/wx.jpg)
 
-<img src="http://static.wildfirechat.cn/ios-settings-view.png" width = 50% height = 50% />
+## 快速使用
+可以按照[快速开始](https://docs.wildfirechat.cn/quick_start/)来部署应用服务和IM服务，然后打包移动端，就可以完成聊天和通话功能。
 
-<img src="http://static.wildfirechat.cn/ios-messagelist-view.png" width = 50% height = 50% />
+之后再部署开放平台服务、频道（公众号）服务、机器人服务、推送服务、Turn服务（音视频服务）来实现完整的应用功能，详情可以详细阅读文档。
 
-<img src="http://static.wildfirechat.cn/ios-chat-setting-view.png" width = 50% height = 50% />
+## 联系我们
+商务合作请微信联系：
 
-<img src="http://static.wildfirechat.cn/ios-takephoto-view.png" width = 50% height = 50% />
+* 微信1：wildfirechat
+* 微信2：wfchat
 
-<img src="http://static.wildfirechat.cn/ios-record-voice-view.png" width = 50% height = 50% />
+## 问题交流
 
-<img src="http://static.wildfirechat.cn/ios-location-view.png" width = 50% height = 50% />
+1. 如果大家发现bug，请在GitHub或码云提issue；如果有需求也请给我们提issue。
+2. 其他问题，请到[野火IM论坛](http://bbs.wildfirechat.cn/)进行交流学习
+3. 关注我们的公众号。我们有新版本发布或者有重大更新会通过公众号通知大家，另外我们也会不定期的发布一些关于野火IM的技术介绍。
+
+<img src="http://static.wildfirechat.cn/wx_wfc_qrcode.jpg" width = 50% height = 50% />
+
+我们有核心研发工程师轮流值班处理issue和论坛，会及时处理的，疑难Bug的修改和新需求的开发我们也会尽快解决。
 
-<img src="http://static.wildfirechat.cn/ios-voip-view.png" width = 50% height = 50% />
 
 ## 编译
-在安装JDK1.8以上及maven的前提下，在命令行中执行```mvn clean compile package```，生成的目标文件在```./distribution/target/distribution-xxxx-bundle-tar.tar.gz```
-> 由于使用了一个git的maven插件，如果本地没有git信息就会编译出错，请使用```git clone```的方法下载代码，或者下载压缩包解压后在根目录创建```.git```的空目录。建议用```git clone```的方式下载代码。
+```
+mvn clean package
+```
+生成的目标文件在```./distribution/target/distribution-xxxx-bundle-tar.tar.gz```
+
+## 配置
+解压```distribution-xxxx-bundle-tar.tar.gz```，修改解压出来的```config```目录下的```wildfirechat.conf```，可以阅读配置文件注释和文档，对其它配置项进行调整。
+
+## 运行
+在解压```distribution-xxxx-bundle-tar.tar.gz```后的目录下运行如下命令：
+```
+./bin/wildfirechat.sh
+```
+
+## 验证
+1. 在浏览器中输入地址 ```http://${ip}/api/version```可以看到返回一个json文件。
+2. 部署[应用服务](https://github.com/wildfirechat/app-server)，配置和编译[Android客户端](https://github.com/wildfirechat/android-chat)和[iOS客户端](https://github.com/wildfirechat/ios-chat)进行验证。详情可参考[快速开始](https://docs.wildfirechat.cn/quick_start/)。
+
+## 打包RPM格式
+打包会生成Java包和deb安装包，如果需要rpm安装包，请在```distribution/pom.xml```中取消注释生成rpm包的plugin。另外还需要本地安装有rpm，在linux或者mac系统中很容易安装，在windows系统需要安装cygwin并安装rpm，具体信息请百度查询。
+
+修改之后运行编译命令```mvn clean package```，rpm包生成在```distribution/target```目录下。
 
 ## 升级说明
 1. 从0.42 版本增加了群成员数限制，默认为2000。如果您从之前的版本升级到这个版本或以后，需要注意到群成员数的限制。升级之后超出限制的群不受影响，但不能继续加人，如果您想修改默认值，可以在升级版本之后，修改t_setting表，把默认的大小改为您期望的人数。另外修改t_group表，把已经存在的群组max_member_count改成您期望的，然后重启。
-2. 0.46和0.47版本升级到0.48及以后版本时，可能会提示flyway migrate 38错误，请执行 [修复脚本](https://github.com/wildfirechat/server/blob/wildfirechat/flyway_repaire_migrate_38.sql) 进行修复。0.46和0.47版本之外的版本不会出现此问题。
-3. 从0.54之前版本升级到0.54及以后版本时，会提示flyway migrate错误。因为0.54版本删除了sql脚本中默认敏感词的内容，flyway checksum失败。请执行```update flyway_schema_history set checksum = 0 where script = 'V17__add_default_sensitive_word.sql';```来修复。
-4. 从0.59之前的版本升级到之后的版本执行数据库升级时间比较长，请耐心等待提示运行成功，避免中途中断。
+2. 0.50版本添加了是否允许客户端发送群操作通知的配置。如果您在客户端自定义群通知，需要在服务器端配置允许，没有使用自定义群操作通知的不受影响。***
+3. 0.46和0.47版本升级到0.48及以后版本时，可能会提示flyway migrate 38错误，请执行 [修复脚本](https://github.com/wildfirechat/server/blob/wildfirechat/flyway_repaire_migrate_38.sql) 进行修复。0.46和0.47版本之外的版本不会出现此问题。
+4. 从0.54之前版本升级到0.54及以后版本时，会提示flyway migrate错误。因为0.54版本删除了sql脚本中默认敏感词的内容，flyway checksum失败。请执行```update flyway_schema_history set checksum = 0 where script = 'V17__add_default_sensitive_word.sql';```来修复。
+5. 从0.59之前的版本升级到之后的版本执行数据库升级时间比较长，请耐心等待提示运行成功，避免中途中断。
+6. 0.62/0.63 版本有严重的问题，请使用0.64及以后版本，或者0.61版。
+7. 从0.68 版本起添加了pc在线是否默认手机接收推送的开关，默认为开，与以前版本作用相反，请注意兼容（可以关掉与之前保持一致或者升级客户端）
+8. 从0.78 版本起把MySQL数据库中关键字都改为大小写敏感，另外生成id的方法也做了改变，只生成小写的id，避免出现id重复的问题，建议所有客户都升级
+9. 从0.79 版本起把log4j升级到log4j2，因为log4j已经不再维护而且还有已知的漏洞，建议所有客户都升级，升级时注意更新log4j2的配置文件
+10. 0.97版本更改了启动脚本```wildfirechat.sh```，如果是升级服务，请注意更新启动脚本。
+
+## 应用截图
+登录界面
+
+<img src="./screenshots/1_login.png" width = 50% height = 50% />
+
+会话列表
+
+<img src="./screenshots/2_conversation_list.png" width = 50% height = 50% />
+
+好友列表
+
+<img src="./screenshots/3_contacts_list.png" width = 50% height = 50% />
+
+工作台
+
+<img src="./screenshots/4_workplatform.png" width = 50% height = 50% />
+
+发现
+
+<img src="./screenshots/5_discover.png" width = 50% height = 50% />
+
+我的页面
+
+<img src="./screenshots/6_settings.png" width = 50% height = 50% />
+
+消息聊天
+
+<img src="./screenshots/7_conversation.png" width = 50% height = 50% />
+
+动态表情
+
+<img src="./screenshots/8_conversation_sticker.png" width = 50% height = 50% />
+
+语音消息
+
+<img src="./screenshots/9_conversation_voice_msg.png" width = 50% height = 50% />
+
+位置消息
+
+<img src="./screenshots/10_conversation_location.png" width = 50% height = 50% />
+
+拍摄图片或者小视频
+
+<img src="./screenshots/11_conversation_capture.jpeg" width = 50% height = 50% />
+
+会话设置
+
+<img src="./screenshots/13_conversation_settings.png" width = 50% height = 50% />
+
+朋友圈
+
+<img src="./screenshots/14_moments.png" width = 50% height = 50% />
+
+新好友
+
+<img src="./screenshots/15_new_friends.png" width = 50% height = 50% />
+
+多人视频通话
+
+<img src="./screenshots/16_videocall.png" width = 50% height = 50% />
+
+会议主页
+
+<img src="./screenshots/17_conference_home.png" width = 50% height = 50% />
+
+会议详情
+
+<img src="./screenshots/18_conference_info.png" width = 50% height = 50% />
+
+会议界面
+
+<img src="./screenshots/19_conference.png" width = 50% height = 50% />
+
+PC客户端界面
+
+<img src="./screenshots/20_pc.png"/>
+
+移动客户端、PC客户端和Web客户端三端同框
+
+<img src="./screenshots/21_three_platform.png" />
+
+小程序客户端
+
+<img src="./screenshots/22_micro_app.jpeg" width = 50% height = 50% />
+
+公众号管理后台
+
+<img src="./screenshots/23_channel.png"/>
+
+开放平台管理后台
+
+<img src="./screenshots/24_open_platform.png" />
+
+IM服务管理后台
+
+<img src="./screenshots/25_im_admin.png" />
+
+> 更多详细信息请下载demo进行体验。
 
 ## 特别感谢
 1. [moquette](https://github.com/moquette-io/moquette) 本项目是基于此项目二次开发而来，处理MQTT相关业务。

broker/config/i18n/messages.properties

@@ -1,3 +0,0 @@
-#native2ascii -encoding UTF-8 messages.properties temp_messages.properties
-Above_Greeting_Message=\u4ee5\u4e0a\u662f\u6253\u62db\u547c\u4fe1\u606f
-Friend_Can_Start_Chat=\u4f60\u4eec\u5df2\u7ecf\u6210\u4e3a\u597d\u53cb\u4e86\uff0c\u73b0\u5728\u53ef\u4ee5\u5f00\u59cb\u804a\u5929\u4e86

broker/config/i18n/messages_en.properties

@@ -1,2 +0,0 @@
-Above_Greeting_Message=This's the greeting
-Friend_Can_Start_Chat=You're already friend, start chat now.

broker/config/i18n/messages_en_US.properties

@@ -1,2 +0,0 @@
-Above_Greeting_Message=This's the greeting
-Friend_Can_Start_Chat=You're already friend, start chat now.

broker/config/i18n/messages_zh.properties

@@ -1,2 +0,0 @@
-Above_Greeting_Message=\u4ee5\u4e0a\u662f\u6253\u62db\u547c\u4fe1\u606f
-Friend_Can_Start_Chat=\u4f60\u4eec\u5df2\u7ecf\u6210\u4e3a\u597d\u53cb\u4e86\uff0c\u73b0\u5728\u53ef\u4ee5\u5f00\u59cb\u804a\u5929\u4e86

broker/config/i18n/messages_zh_CN.properties

@@ -1,2 +0,0 @@
-Above_Greeting_Message=\u4ee5\u4e0a\u662f\u6253\u62db\u547c\u4fe1\u606f
-Friend_Can_Start_Chat=\u4f60\u4eec\u5df2\u7ecf\u6210\u4e3a\u597d\u53cb\u4e86\uff0c\u73b0\u5728\u53ef\u4ee5\u5f00\u59cb\u804a\u5929\u4e86

broker/config/wildfirechat.conf

@@ -12,7 +12,7 @@
 #服务器的接入IP。给客户端提供是${server.ip}和${http_port}。
 #客户端会从${http_port}端口获取到长链接端口。这个地址一定要改成客户端可以访问到的IP地址
 #（如果您部署云服务器上或者具有独立公网出口的服务器上，请改为对应的公网IP；如果您部署在在内网环境下，在内网使用，这个地方改成内网地址）
-server.ip 192.168.3.124
+server.ip 192.168.1.81
 
 ##原生客户端长链接端口
 port 1883
@@ -26,20 +26,25 @@ http.admin.port 18080
 ##节点ID，当集群部署时，一定不能有重复。
 node_id 1
 
-##绑定IP，保持不变即可
-host 0.0.0.0
+##绑定IP，不要打开，除非有特殊需求才可以打开
+#host 0.0.0.0
 
 ##本地绑定端口
 local_port 80
 
-##是否使用内置DB。0使用mysql；1使用h2db。
+## 是否使用内置DB。0使用mysql；1使用h2db。
+## MySQL需要把事物隔离级别改成"Read committed"，使用命令来修改"set global transaction_isolation='read-committed';"，其他数据库默认已经是这个级别不用修改
 embed.db 1
 
 ## 是否自动清理历史消息记录，当为true时，IM服务会定时扫描t_messages_x和t_user_messages_x表，清除掉3年前的历史消息。
 ## 如果不开启自动清理，需要手动清理t_messages_x和t_user_messages_x表内的历史数据，保存数据不能超过3年。
+## 如果需要消息保存更长时间，可以把临近销毁的消息转储到别的数据库，客户端在拉取不到服务器消息时，再去转储的数据库拉取。
 ## 使用mongodb时次开关无效（因为mongodb设置了消息过期时间，会自动清理，仅专业版支持mongodb）。
 db.auto_clean_history_messages true
 
+## h2db数据库的路径，默认为程序目录下的，可以指定其他目录。如果使用MySQL，可以忽略此配置
+h2db.path ./h2db/wfchat
+
 ##服务器管理接口密钥。如果修改此端口需要同步修改使用管理API的地方，比如应用服务。
 http.admin.secret_key 123456
 
@@ -54,11 +59,20 @@ token.key testim
 ##token的过期时间，单位为毫秒，默认为无限期。如果需要设置无限期，客户端上一定需要加上token过期的处理。token过期的处理请参考文档的常见问题
 ##token.expire_time 2592000000
 
+##客户端（目前只有android）的应用签名（一个应用最取第一个签名），如果有多个签名(多个客户端)，用英文逗号分开。获取签名方法请参考文档：https://docs.wildfirechat.cn/blogs/签名验证.html
+#connect.client_signature_list eNkezQ1g9OsnhfLSFUY1vzKDzhs=,xykezQ1g9OsnhfLSFUY1vzKDzhs=
+
+##是否拒绝空签名的android客户端， 默认为true。当有旧的客户端需要兼容时改成false，当所有都是新客户端时，改成true。
+#connect.reject_empty_signature true
+
 ##首次登录，是否接收之前的历史消息。
-##0 不接收历史消息，只接收5分钟以内的消息，由于服务器没有保存已经收取记录，所以如果有超过5分钟之前未收取的消息也不会收取下拉；
+##0 不接收历史消息，只接收${message.compensate_time_limit}毫秒以内的消息，由于服务器没有保存已经收取记录，所以如果有超过${message.compensate_time_limit}毫秒之前未收取的消息也不会收取下拉；
 ##1接收，会接收 message.max_queue 配置的条数的历史消息
 message.roaming 0
 
+## 消息补偿时限，当${message.roaming}为0时，会同步时限以内且小于${message.max_queue}的消息，默认时限为5分钟。当${message.roaming}为1时，会接收 message.max_queue 配置的条数的历史消息。
+message.compensate_time_limit 300000
+
 ##是否开启拉取远程历史消息。如果为1，客户端在会话内如果本地消息读取完了，可以下拉继续加载在服务器上的该会话的消息；如果为0则不能。
 message.remote_history_message 0
 
@@ -71,6 +85,9 @@ message.chatroom_remote_history_message 1
 ##是否禁止陌生人聊天
 message.disable_stranger_chat false
 
+##当禁止陌生人聊天时，允许聊天的用户id，比如管理员或者文件传输助手等。用户id以英文逗号分割。
+message.allow_stranger_chat_list admin,FireRobot,wfc_file_transfer
+
 ##黑名单策略，0 发送失败，返回被拉黑的错误码；1 发送成功但消息被服务器直接丢弃
 message.blacklist.strategy 0
 
@@ -107,6 +124,14 @@ message.global_mute_exception_types 401,402,403,404,405,407,408,410,411
 ## 当为true时，不转发server api发送的消息；当为false时，转发server api发送的消息。
 message.no_forward_admin_message false
 
+## 消息转发功能开启时，转发信息是否带上用户clientId和平台类型。
+message.forward_with_client_info false
+
+## 机器人回调信息是否带上用户clientId和平台类型。
+robot.callback_with_client_info false
+
+## 频道回调信息是否带上用户clientId和平台类型。
+channel.callback_with_client_info false
 
 ##禁止搜索用户
 friend.disable_search false
@@ -117,21 +142,15 @@ friend.disable_nick_name_search false
 ##禁止发送好友邀请，通过server api添加好友不受此限制(force参数需要为true)
 friend.disable_friend_request false
 
-##好友请求重复发送的间隔，单位是毫秒，默认是7天，0为不限制
+##好友请求重复发送的间隔，单位是毫秒，默认是7天，0为无限长期限。
 friend.repeat_request_duration 604800000
 
-##好友请求被拒绝后再次发送的间隔，单位是毫秒，默认是30天，0为不限制
+##好友请求被拒绝后再次发送的间隔，单位是毫秒，默认是30天，0为不限制。不能小于friend.repeat_request_duration。
 friend.reject_request_duration 2592000000
 
-##好友请求过期时间，单位是毫秒，默认是7天，0为不限制
+##好友请求过期时间，单位是毫秒，默认是7天，0为无限长期限。
 friend.request_expiration_duration 604800000
 
-##添加好友后会发送欢迎消息，比如"你们已经是好友了，可以聊天了"。这个开关控制是用旧的方式还是用新的方式。
-##旧的方式会发送notification消息（contenttype是80），内容会根据好友接收者的语言选择对应的语言，如果双方语言不一致会导致另外一方看到的不是本地语言。
-##新的方式会发送添加好友消息（contenttype是93）和欢迎消息（contenttype是92），需要客户端实现这两种消息。
-##如果客户端已经实现这两种消息可以打开这个开关（客户端2020.6.30添加了此消息类型）。
-friend.new_welcome_message true
-
 ## 聊天室观众空闲退出时间，单位为毫秒，默认为15分钟，0为永远不退出
 chatroom.participant_idle_time 900000
 
@@ -151,11 +170,18 @@ group.allow_robot_custom_operation_notification true
 ## 0 不发送，1 退群时发送，2 踢人时发送，3 退群和踢人时都发送。
 group.visible_quit_or_kickoff_notification 0
 
+## 禁止客户端群操作。第1位是禁止创建群组，第2位是禁止销毁群组，3位禁止加入群，4位禁止退出群，5位禁止邀请群成员，6位禁止移出群成员，7位禁止转移群，8位禁止设置群管理员，9位禁止白名单处理，10位禁止群禁言，11位禁止修改群组信息，12位禁止群成员禁言。
+## Server API不受此限制。
+#group.forbidden_client_operation 0xFFF
+
 ## 隐藏用户信息属性类型，2是性别，3是电话号码，4是邮箱，5是地址，6是公司信息，7是社交账号，8是Extra信息。当需要隐藏多个时以英文逗号分开;
 ## 本配置是为了提高安全性，避免把对应信息同步到客户端，这样就能防止程序被破解从而拿到用户关键信息。仅对客户端有效，server api不受影响。
 ## 注意，修改本配置不会对已经同步的信息产生影响。
 #user.hide_properties 3,4,5
 
+## 销毁用户时，用户信息会被清空，deleted字段设置为1，这个开关控制是否保留用户昵称，默认为true。
+user.keep_display_name_when_destroy true
+
 # 好友/好友请求/用户设置 这三类数据同步的最大条目数。之前是客户第一次登录时，会把所有的对应数据一次下载到客户端，但如果有特别多的信息，会导致无法同步到客户端，
 # 因此需要分段多次同步，此开关定义了每次同步的数据的条数。此需要客户端支持，客户端SDK在2021.5.25日后支持此功能。如果确认所有客户端都在这个日志之后才可以打开此设置。
 #sync.data_part_size 1000
@@ -174,11 +200,6 @@ http.channel.rate_limit 1000
 ##客户端请求频率限制，默认是5秒100次。通常情况下不要修改这个值。
 client.request_rate_limit 100
 
-#*********************************************************************
-# hazelcase configuration
-#*********************************************************************
-hazelcast.configuration config/hazelcast.xml
-
 #*********************************************************************
 # Media server configuration
 #*********************************************************************
@@ -234,6 +255,9 @@ local.media.storage.root media
 # 建议使用false
 server.multi_endpoint false
 
+## 是否支持PC多端登陆，当server.multi_endpoint为true时，此开关无意义，当为false时，可以单独打开PC端多端登录。
+server.multi_pc_endpoint false
+
 # 多平台连接状态通知（仅当multi_endpoint为false时有效），true时移动端可以收到pc或web端登录的通知。
 server.multi_platform_notification true
 
@@ -282,13 +306,23 @@ push.ios.server.address http://localhost:8085/ios/push
 ##消息转发地址
 ##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
 #message.forward.url http://localhost:8888/im_event/message
-##需要转发的消息类型，当有多个时以英文逗号分割。如果转发所有消息，请注释掉配置或者设置为空
-#message.forward.types 1,2,3
+##需要转发的消息类型，当有多个时以英文逗号分割，可以用-来指定区间，注意区间不能太大，因为要把区间内的所有数字都放入到Set中。如果转发所有消息，请注释掉配置或者设置为空
+#message.forward.types 1,2,3,5-10
+##需要转发的消息类型，当有多个时以英文逗号分割，可以用-来指定区间，注意区间不能太大，因为要把区间内的所有数字都放入到Set中。
+#message.forward.exclude_types 1,2,3,5-10
 
-##提醒消息转发地址，@全体用户和@某个用户消息会回调此地址。此转发不受${message.forward.types}限制。
+##敏感消息转发地址
+##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
+#message.sensitive.forward.url http://localhost:8888/im_event/message
+
+##提醒消息转发地址，@全体用户和@某个用户消息会回调此地址。
+##此转发不受${message.forward.types}和${message.forward.exclude_types}限制。
 ##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
 #message.mentionmsg.forward.url http://localhost:8888/im_event/message
 
+##撤回消息转发地址，当用户撤回消息会回调此地址。
+##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！
+#message.recallmsg.forward.url http://localhost:8888/im_event/recall_message
 
 ##设备信息转发地址
 ##注意回调是单线程回调，接收服务必须在同一内网，且异步处理快速返回，否则会有延迟问题！！

broker/migrate/h2/V41__alter_user_setting_key_column.sql

@@ -0,0 +1 @@
+alter table `t_user_setting` modify column `_key` varchar(128) NOT NULL;

broker/migrate/h2/V42__create_secret_chat_table.sql

@@ -0,0 +1,13 @@
+
+DROP TABLE IF EXISTS `t_secret_chat`;
+CREATE TABLE `t_secret_chat` (
+  `id` int(11) NOT NULL PRIMARY KEY AUTO_INCREMENT,
+  `_uid` varchar(64) NOT NULL,
+  `_from` varchar(64) DEFAULT '',
+  `_from_cid` varchar(64) DEFAULT '',
+  `_to` varchar(64) DEFAULT '',
+  `_to_cid` varchar(64) DEFAULT '',
+  `_state` tinyint NOT NULL DEFAULT 0,
+  `_dt` bigint(20) NOT NULL,
+  UNIQUE INDEX `secret_chat_uid_index` (`_uid` DESC)
+);

broker/migrate/h2/V43__add_message_table_conversation_index.sql

@@ -0,0 +1 @@
+alter table `t_messages` add INDEX `messages_conv_index` ( `_type`, `_target`, `_line`);

broker/migrate/h2/V44__add_channel_listener_table_member_index.sql

@@ -0,0 +1 @@
+alter table `t_channel_listener` add INDEX `channel_mid_index` ( `_mid`);

broker/migrate/h2/V45__add_channel_menu_column.sql

@@ -0,0 +1 @@
+alter table `t_channel` add column `_menu` BLOB DEFAULT NULL;

broker/migrate/h2/V46__add_group_member_mid_index.sql

@@ -0,0 +1 @@
+alter table `t_group_member` add INDEX `group_member_mid_index` (`_mid`);

broker/migrate/h2/V47__create_super_group.sql

@@ -0,0 +1,19 @@
+alter table `t_group` add column `_super_group` tinyint NOT NULL DEFAULT 0;
+
+DROP TABLE IF EXISTS `t_group_messages`;
+CREATE TABLE `t_group_messages` (
+    `_mid` bigint(20) NOT NULL PRIMARY KEY,
+    `_sender` varchar(64) NOT NULL,
+    `_gid` varchar(64) NOT NULL,
+    `_line` int(11) NOT NULL,
+    `_client_id` varchar(64) NULL,
+    `_seq` bigint(20) NOT NULL,
+    `_persist_flag` int(11) NOT NULL,
+    `_mentioned_type` int(11) NOT NULL,
+    `_mentioned_targets` BLOB NULL,
+    `_to` BLOB NULL,
+    `_cont_type` int(11) NOT NULL DEFAULT 0,
+    `_duration` int(11) NOT NULL DEFAULT 0,
+    `_dt` bigint(20) NOT NULL DEFAULT 0,
+    INDEX `group_message_seq_uid_index` (`_gid` DESC, `_line`, `_seq` DESC)
+);

broker/migrate/mysql/V47__fix_read_report_error.sql

@@ -0,0 +1,3 @@
+
+ALTER TABLE `t_read_report` MODIFY COLUMN `_uid` VARCHAR(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL;
+ALTER TABLE `t_read_report` MODIFY COLUMN `_target` VARCHAR(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL;

broker/migrate/mysql/V48__alter_user_setting_key_column.sql

@@ -0,0 +1 @@
+alter table `t_user_setting` modify column `_key` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL;

broker/migrate/mysql/V49__create_secret_chat_table.sql

@@ -0,0 +1,16 @@
+
+DROP TABLE IF EXISTS `t_secret_chat`;
+CREATE TABLE `t_secret_chat` (
+  `id` int(11) NOT NULL PRIMARY KEY AUTO_INCREMENT,
+  `_uid` varchar(64) NOT NULL,
+  `_from` varchar(64) DEFAULT '',
+  `_from_cid` varchar(64) DEFAULT '',
+  `_to` varchar(64) DEFAULT '',
+  `_to_cid` varchar(64) DEFAULT '',
+  `_state` tinyint NOT NULL DEFAULT 0,
+  `_dt` bigint(20) NOT NULL,
+  UNIQUE INDEX `secret_chat_uid_index` (`_uid` DESC)
+)
+ENGINE = InnoDB
+DEFAULT CHARACTER SET = utf8mb4
+COLLATE = utf8mb4_bin;

broker/migrate/mysql/V50__add_message_table_conversation_index.sql

@@ -0,0 +1,37 @@
+alter table `t_messages` add INDEX `messages_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_0` add INDEX `messages0_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_1` add INDEX `messages1_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_2` add INDEX `messages2_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_3` add INDEX `messages3_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_4` add INDEX `messages4_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_5` add INDEX `messages5_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_6` add INDEX `messages6_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_7` add INDEX `messages7_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_8` add INDEX `messages8_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_9` add INDEX `messages9_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_10` add INDEX `messages10_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_11` add INDEX `messages11_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_12` add INDEX `messages12_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_13` add INDEX `messages13_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_14` add INDEX `messages14_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_15` add INDEX `messages15_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_16` add INDEX `messages16_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_17` add INDEX `messages17_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_18` add INDEX `messages18_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_19` add INDEX `messages19_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_20` add INDEX `messages20_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_21` add INDEX `messages21_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_22` add INDEX `messages22_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_23` add INDEX `messages23_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_24` add INDEX `messages24_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_25` add INDEX `messages25_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_26` add INDEX `messages26_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_27` add INDEX `messages27_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_28` add INDEX `messages28_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_29` add INDEX `messages29_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_30` add INDEX `messages30_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_31` add INDEX `messages31_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_32` add INDEX `messages32_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_33` add INDEX `messages33_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_34` add INDEX `messages34_conv_index` (`_type`, `_target`, `_line`);
+alter table `t_messages_35` add INDEX `messages35_conv_index` (`_type`, `_target`, `_line`);

broker/migrate/mysql/V51__add_channel_listener_table_member_index.sql

@@ -0,0 +1 @@
+alter table `t_channel_listener` add INDEX `channel_mid_index` (`_mid`);

broker/migrate/mysql/V52__add_channel_menu_column.sql

@@ -0,0 +1 @@
+alter table `t_channel` add column `_menu` BLOB DEFAULT NULL;

broker/migrate/mysql/V53__add_group_member_mid_index.sql

@@ -0,0 +1 @@
+alter table `t_group_member` add INDEX `group_member_mid_index` (`_mid`);

broker/pom.xml

@@ -1,11 +1,11 @@
-<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <relativePath>../</relativePath>
         <artifactId>wildfirechat-parent</artifactId>
         <groupId>cn.wildfirechat</groupId>
-        <version>0.78</version>
+        <version>1.1.3</version>
     </parent>
 
     <artifactId>moquette-broker</artifactId>
@@ -18,37 +18,45 @@
     </properties>
 
     <dependencies>
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-api</artifactId>
-            <version>1.7.5</version>
-        </dependency>
-
-        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-log4j12</artifactId>
-            <version>1.7.5</version>
-        </dependency>
-
         <dependency>
             <groupId>cn.wildfirechat</groupId>
             <artifactId>common</artifactId>
             <version>${project.version}</version>
         </dependency>
 
-        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
         <dependency>
-            <groupId>log4j</groupId>
-            <artifactId>log4j</artifactId>
-            <version>1.2.17</version>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>2.17.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-api</artifactId>
+            <version>2.17.2</version>
+        </dependency>
+        <!--用于与slf4j保持桥接-->
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-slf4j-impl</artifactId>
+            <version>2.17.2</version>
+        </dependency>
+        <!-- slf4j核心包-->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>1.7.25</version>
+        </dependency>
+        <dependency>
+            <groupId>com.lmax</groupId>
+            <artifactId>disruptor</artifactId>
+            <version>3.4.1</version>
         </dependency>
 
         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
-            <version>8.0.19</version>
+            <version>8.0.28</version>
         </dependency>
 
         <dependency>
@@ -112,7 +120,7 @@
         <dependency>
             <groupId>commons-codec</groupId>
             <artifactId>commons-codec</artifactId>
-            <version>1.10</version>
+            <version>1.13</version>
         </dependency>
 
         <dependency>
@@ -226,6 +234,11 @@
             <version>3.4.1</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.apache.tika</groupId>
+            <artifactId>tika-core</artifactId>
+            <version>2.4.1</version>
+        </dependency>
     </dependencies>
 
 

broker/src/main/java/cn/wildfirechat/push/PushServer.java

@@ -11,6 +11,7 @@ package cn.wildfirechat.push;
 import cn.wildfirechat.common.IMExceptionEvent;
 import cn.wildfirechat.proto.ProtoConstants;
 import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
 import io.moquette.persistence.MemorySessionStore;
 import io.moquette.server.config.IConfig;
 import io.moquette.spi.ISessionsStore;
@@ -29,7 +30,7 @@ import static win.liyufan.im.HttpUtils.HttpPostType.POST_TYPE_Push;
 
 public class PushServer {
     private static final Logger LOG = LoggerFactory.getLogger(PushServer.class);
-
+    protected static final Gson gson = new GsonBuilder().disableHtmlEscaping().create();
     public interface PushMessageType {
         int PUSH_MESSAGE_TYPE_NORMAL = 0;
         int PUSH_MESSAGE_TYPE_VOIP_INVITE = 1;
@@ -100,7 +101,7 @@ public class PushServer {
                 url = iOSPushServerUrl;
                 pushMessage.voipDeviceToken = session.getVoipDeviceToken();
             }
-            HttpUtils.httpJsonPost(url, new Gson().toJson(pushMessage, pushMessage.getClass()), POST_TYPE_Push);
+            HttpUtils.httpJsonPost(url, gson.toJson(pushMessage, pushMessage.getClass()), POST_TYPE_Push);
         } else {
             LOG.info("Not mobile platform {}", session.getPlatform());
         }

broker/src/main/java/com/xiaoleilu/loServer/action/Action.java

@@ -9,6 +9,7 @@
 package com.xiaoleilu.loServer.action;
 
 import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
 import com.xiaoleilu.loServer.RestResult;
 import com.xiaoleilu.loServer.annotation.RequireAuthentication;
 import com.xiaoleilu.loServer.handler.Request;
@@ -39,7 +40,7 @@ import static io.moquette.BrokerConstants.*;
 abstract public class Action {
     public static IMessagesStore messagesStore = null;
     public static ISessionsStore sessionsStore = null;
-
+    protected static final Gson gson = new GsonBuilder().disableHtmlEscaping().create();
     public ChannelHandlerContext ctx;
 
     protected static RateLimiter adminLimiter = null;
@@ -129,7 +130,7 @@ abstract public class Action {
             }
 
             RestResult result = RestResult.resultOf(errorCode, errorCode.getMsg(), RestResult.resultOf(errorCode));
-            response.setContent(new Gson().toJson(result));
+            response.setContent(gson.toJson(result));
             response.send();
         }
 
@@ -145,7 +146,7 @@ abstract public class Action {
             FullHttpRequest fullHttpRequest = (FullHttpRequest) request;
             byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
             String content = new String(bytes, StandardCharsets.UTF_8);//contribute by JiaRG from github
-            Gson gson = new Gson();
+            
             T t = gson.fromJson(content, cls);
             return t;
         }
@@ -154,6 +155,6 @@ abstract public class Action {
 
     protected void setResponseContent(RestResult result, Response response) {
         response.setStatus(HttpResponseStatus.OK);
-        response.setContent(new Gson().toJson(result));
+        response.setContent(gson.toJson(result));
     }
 }

broker/src/main/java/com/xiaoleilu/loServer/action/FileAction.java

@@ -90,6 +90,8 @@ public class FileAction extends Action {
         }
 
         response.setContent(file);
+        response.setHeader("Content-Disposition", "attachment; filename=\"" + file.getName() + "\"");
+
         return true;
     }
 

broker/src/main/java/com/xiaoleilu/loServer/action/IMAction.java

@@ -80,6 +80,11 @@ public class IMAction extends Action {
                 if (userId == null) {
                     sendResponse(response, ErrorCode.ERROR_CODE_TOKEN_ERROR, null);
                 } else {
+                    if(messagesStore.getUserStatus(userId) == ProtoConstants.UserStatus.Forbidden) {
+                        sendResponse(response, ErrorCode.ERROR_CODE_USER_BLOCKED, null);
+                        return true;
+                    }
+
                     ServerAPIHelper.sendRequest(userId, wrapper.getClientId(), wrapper.getRequest(), wrapper.getData().toByteArray(), new ServerAPIHelper.Callback() {
                         @Override
                         public void onSuccess(byte[] result) {

broker/src/main/java/com/xiaoleilu/loServer/action/RouteAction.java

@@ -39,17 +39,10 @@ public class RouteAction extends Action {
     @Override
     public boolean action(Request request, Response response) {
         if (request.getNettyRequest() instanceof FullHttpRequest) {
-
             response.setContentType("application/octet-stream");
             response.setHeader("Access-Control-Allow-Origin", "*");
 
             FullHttpRequest fullHttpRequest = (FullHttpRequest) request.getNettyRequest();
-            boolean b = false;
-            if ("web".equalsIgnoreCase(fullHttpRequest.headers().get("p"))) {
-                b = true;
-            }
-
-            final boolean base64Response = b;
 
             byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
 
@@ -57,15 +50,20 @@ public class RouteAction extends Action {
             try {
                 bytes = Base64.getDecoder().decode(str);
             } catch (IllegalArgumentException e) {
-                sendResponse(response, ErrorCode.ERROR_CODE_INVALID_DATA, null, base64Response);
+                sendResponse(response, ErrorCode.ERROR_CODE_INVALID_DATA, null);
                 return true;
             }
 
             String cid = fullHttpRequest.headers().get("cid");
             byte[] cbytes = Base64.getDecoder().decode(cid);
-            cbytes = AES.AESDecrypt(cbytes, "", true);
+            boolean[] invalidTime = new boolean[1];
+            cbytes = AES.AESDecrypt(cbytes, "", true, invalidTime);
             if (cbytes == null) {
-                sendResponse(response, ErrorCode.ERROR_CODE_INVALID_DATA, null, base64Response);
+                if(invalidTime[0]) {
+                    sendResponse(response, ErrorCode.ERROR_CODE_TIME_INCONSISTENT, null);
+                } else {
+                    sendResponse(response, ErrorCode.ERROR_CODE_INVALID_DATA, null);
+                }
                 return true;
             }
             cid = new String(cbytes);
@@ -74,7 +72,7 @@ public class RouteAction extends Action {
             byte[] ubytes = Base64.getDecoder().decode(uid);
             ubytes = AES.AESDecrypt(ubytes, "", true);
             if (ubytes == null) {
-                sendResponse(response, ErrorCode.ERROR_CODE_INVALID_DATA, null, base64Response);
+                sendResponse(response, ErrorCode.ERROR_CODE_INVALID_DATA, null);
                 return true;
             }
             uid = new String(ubytes);
@@ -84,7 +82,7 @@ public class RouteAction extends Action {
             if (session == null) {
                 ErrorCode errorCode = sessionsStore.loadActiveSession(uid, cid);
                 if (errorCode != ErrorCode.ERROR_CODE_SUCCESS) {
-                    sendResponse(response, errorCode, null, base64Response);
+                    sendResponse(response, errorCode, null);
                     return true;
                 }
                 session = sessionsStore.sessionForClientAndUser(uid, cid);
@@ -94,16 +92,20 @@ public class RouteAction extends Action {
             if (session != null) {
                 bytes = AES.AESDecrypt(bytes, session.getSecret(), true);
             } else {
-                sendResponse(response, ErrorCode.ERROR_CODE_SECRECT_KEY_MISMATCH, null, base64Response);
+                sendResponse(response, ErrorCode.ERROR_CODE_SECRECT_KEY_MISMATCH, null);
                 return true;
             }
 
 
             if (bytes == null) {
-                sendResponse(response, ErrorCode.ERROR_CODE_SECRECT_KEY_MISMATCH, null, base64Response);
+                sendResponse(response, ErrorCode.ERROR_CODE_SECRECT_KEY_MISMATCH, null);
                 return true;
             }
 
+            if(messagesStore.getUserStatus(uid) == ProtoConstants.UserStatus.Forbidden) {
+                sendResponse(response, ErrorCode.ERROR_CODE_USER_BLOCKED, null);
+                return true;
+            }
 
             try {
                 WFCMessage.IMHttpWrapper wrapper = WFCMessage.IMHttpWrapper.parseFrom(bytes);
@@ -111,22 +113,22 @@ public class RouteAction extends Action {
                 String userId = Tokenor.getUserId(token.getBytes());
                 LOG.info("RouteAction token={}, userId={}", token, userId);
                 if (userId == null) {
-                    sendResponse(response, ErrorCode.ERROR_CODE_TOKEN_ERROR, null, base64Response);
+                    sendResponse(response, ErrorCode.ERROR_CODE_TOKEN_ERROR, null);
                 } else {
                     ServerAPIHelper.sendRequest(userId, wrapper.getClientId(), wrapper.getRequest(), wrapper.getData().toByteArray(), new ServerAPIHelper.Callback() {
                         @Override
                         public void onSuccess(byte[] result) {
-                            sendResponse(response, null, result, base64Response);
+                            sendResponse(response, null, result);
                         }
 
                         @Override
                         public void onError(ErrorCode errorCode) {
-                            sendResponse(response, errorCode, null, base64Response);
+                            sendResponse(response, errorCode, null);
                         }
 
                         @Override
                         public void onTimeout() {
-                            sendResponse(response, ErrorCode.ERROR_CODE_TIMEOUT, null, base64Response);
+                            sendResponse(response, ErrorCode.ERROR_CODE_TIMEOUT, null);
                         }
 
                         @Override
@@ -139,25 +141,21 @@ public class RouteAction extends Action {
                     return false;
                 }
             } catch (InvalidProtocolBufferException e) {
-                sendResponse(response, ErrorCode.ERROR_CODE_INVALID_DATA, null, false);
+                sendResponse(response, ErrorCode.ERROR_CODE_INVALID_DATA, null);
             }
         }
         return true;
     }
 
-    private void sendResponse(Response response, ErrorCode errorCode, byte[] contents, boolean base64Response) {
+    private void sendResponse(Response response, ErrorCode errorCode, byte[] contents) {
         response.setStatus(HttpResponseStatus.OK);
         if (contents == null) {
             ByteBuf ackPayload = Unpooled.buffer();
             ackPayload.ensureWritable(1).writeByte(errorCode.getCode());
             contents = ackPayload.array();
         }
-        if (base64Response) {
-            byte[] base64Data = Base64.getEncoder().encode(contents);
-            response.setContent(base64Data);
-        } else {
-            response.setContent(contents);
-        }
+
+        response.setContent(contents);
         response.send();
     }
 }

broker/src/main/java/com/xiaoleilu/loServer/action/UploadFileAction.java

@@ -131,7 +131,8 @@ public class UploadFileAction extends Action {
                 }
 
                 readHttpDataChunkByChunk(response, decoder, requestId, HttpHeaders.isKeepAlive(request));
-
+                decoder.destroy();
+                
                 if (chunk instanceof LastHttpContent) {
 
                 }
@@ -186,6 +187,10 @@ public class UploadFileAction extends Action {
                     return false;
                 }
 
+                if(remoteFileName != null && remoteFileName.length() > 2 && remoteFileName.startsWith("'") && remoteFileName.endsWith("'")) {
+                    remoteFileName = remoteFileName.substring(1, remoteFileName.length()-1);
+                }
+
                 if (StringUtil.isNullOrEmpty(remoteFileName)) {
                     logger.warn("remoteFileName is empty!");
 
@@ -234,12 +239,17 @@ public class UploadFileAction extends Action {
                 int offset = 0; // 断点续传开始位置
 
                 Date nowTime=new Date();
-                SimpleDateFormat time=new SimpleDateFormat("yyyy/MM/dd/HH");
+                SimpleDateFormat time=new SimpleDateFormat("yyyy/MM/dd/HH/mm/ss");
                 String datePath = time.format(nowTime);
 
                 datePath = "fs/" + bucket[0] + "/" + datePath; //add bucket
 
-                String dir = "./" + MediaServerConfig.FILE_STROAGE_ROOT + "/" + datePath;
+                String dir;
+                if(MediaServerConfig.FILE_STROAGE_ROOT.startsWith("/") || MediaServerConfig.FILE_STROAGE_ROOT.startsWith("~/") || MediaServerConfig.FILE_STROAGE_ROOT.startsWith("./")) {
+                    dir = MediaServerConfig.FILE_STROAGE_ROOT + "/" + datePath;
+                } else {
+                    dir = "./" + MediaServerConfig.FILE_STROAGE_ROOT + "/" + datePath;
+                }
 
                 File dirFile = new File(dir);
                 boolean bFile  = dirFile.exists();
@@ -247,6 +257,7 @@ public class UploadFileAction extends Action {
                 if(!bFile) {
                     bFile = dirFile.mkdirs();
                     if (!bFile) {
+                        logger.error("create dirs error! {}", dir);
                         response.setStatus(HttpResponseStatus.INTERNAL_SERVER_ERROR);
                         response.setContent("服务器错误：无法创建文件");
                         return false;

broker/src/main/java/com/xiaoleilu/loServer/action/VersionAction.java

@@ -34,7 +34,7 @@ public class VersionAction extends Action {
 
             try {
 
-                response.setContent(Utility.formatJson(new Gson().toJson(GitRepositoryState.getGitRepositoryState())));
+                response.setContent(Utility.formatJson(gson.toJson(GitRepositoryState.getGitRepositoryState())));
             } catch (IOException e) {
                 e.printStackTrace();
                 response.setContent("{\"version\":\"unknown\"}");

broker/src/main/java/com/xiaoleilu/loServer/action/admin/AdminAction.java

@@ -34,6 +34,10 @@ abstract public class AdminAction extends Action {
         SECRET_KEY = secretKey;
     }
 
+    public static String getSecretKey() {
+        return SECRET_KEY;
+    }
+
     public static void setNoCheckTime(String noCheckTime) {
         try {
             NO_CHECK_TIME = Boolean.parseBoolean(noCheckTime);
@@ -95,7 +99,7 @@ abstract public class AdminAction extends Action {
             }
 
             RestResult result = RestResult.resultOf(errorCode, errorCode.getMsg(), data);
-            response.setContent(new Gson().toJson(result));
+            response.setContent(gson.toJson(result));
             response.send();
         }
     }
@@ -108,7 +112,7 @@ abstract public class AdminAction extends Action {
     }
 
     protected void sendApiMessage(Response response, String fromUser, String clientId, String topic, byte[] message, ApiCallback callback, boolean noAdmin) {
-        ServerAPIHelper.sendRequest(fromUser, clientId, topic, message, new ServerAPIHelper.Callback() {
+        ServerAPIHelper.sendRequest(fromUser, clientId, topic, message, callback == null ? null : new ServerAPIHelper.Callback() {
             @Override
             public void onSuccess(byte[] result) {
                 if(callback != null) {

broker/src/main/java/com/xiaoleilu/loServer/action/admin/ApplicationGetUserInfoAction.java

@@ -0,0 +1,58 @@
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputApplicationGetUserInfo;
+import cn.wildfirechat.pojos.OutputApplicationUserInfo;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import com.google.gson.Gson;
+import com.hazelcast.util.StringUtil;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+
+@Route(APIPath.User_Application_Get_UserInfo)
+@HttpMethod("POST")
+public class ApplicationGetUserInfoAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputApplicationGetUserInfo inputUserToken = getRequestBody(request.getNettyRequest(), InputApplicationGetUserInfo.class);
+
+            RestResult result;
+            if (inputUserToken == null || StringUtil.isNullOrEmpty(inputUserToken.getAuthCode())) {
+                result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
+            } else {
+                String userId = messagesStore.verifyApplicationAuthCode(inputUserToken.getAuthCode(), "admin", ProtoConstants.ApplicationType.ApplicationType_Admin);
+                if(userId != null) {
+                    OutputApplicationUserInfo outputVerifyApplicationUser = new OutputApplicationUserInfo();
+                    outputVerifyApplicationUser.setUserId(userId);
+                    WFCMessage.User user = messagesStore.getUserInfo(userId);
+                    if(user != null) {
+                        outputVerifyApplicationUser.setDisplayName(user.getDisplayName());
+                        outputVerifyApplicationUser.setPortraitUrl(user.getPortrait());
+                    }
+                    result = RestResult.ok(outputVerifyApplicationUser);
+                } else {
+                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_TOKEN_ERROR);
+                }
+            }
+
+            response.setStatus(HttpResponseStatus.OK);
+            response.setContent(gson.toJson(result));
+        }
+        return true;
+    }
+}
+

broker/src/main/java/com/xiaoleilu/loServer/action/admin/BlockUserAction.java

@@ -42,7 +42,7 @@ public class BlockUserAction extends AdminAction {
                 response.setStatus(HttpResponseStatus.OK);
                 RestResult result;
                 result = RestResult.resultOf(errorCode);
-                response.setContent(new Gson().toJson(result));
+                response.setContent(gson.toJson(result));
 
                 if (inputUserBlock.getStatus() == 2) {
                     sendApiMessage(null, null, ServerAPIHelper.KICKOFF_USER_REQUEST, inputUserBlock.getUserId().getBytes(), null);

broker/src/main/java/com/xiaoleilu/loServer/action/admin/ChannelSubscriberAction.java

@@ -0,0 +1,62 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputChannelSubscribe;
+import cn.wildfirechat.pojos.InputCreateChannel;
+import cn.wildfirechat.pojos.InputSubscribeChannel;
+import cn.wildfirechat.pojos.OutputCreateChannel;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import com.google.gson.Gson;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.action.channel.ChannelAction;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.util.internal.StringUtil;
+import win.liyufan.im.IMTopic;
+
+@Route(APIPath.Subscribe_Channel)
+@HttpMethod("POST")
+public class ChannelSubscriberAction extends AdminAction {
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputSubscribeChannel inputSubscribeChannel = getRequestBody(request.getNettyRequest(), InputSubscribeChannel.class);
+            if (inputSubscribeChannel != null
+                && !io.netty.util.internal.StringUtil.isNullOrEmpty(inputSubscribeChannel.getChannelId())
+                && !io.netty.util.internal.StringUtil.isNullOrEmpty(inputSubscribeChannel.getUserId())) {
+
+                WFCMessage.ListenChannel.Builder builder = WFCMessage.ListenChannel.newBuilder().setChannelId(inputSubscribeChannel.getChannelId()).setListen(inputSubscribeChannel.getSubscribe());
+                sendApiMessage(response, inputSubscribeChannel.getUserId(), IMTopic.ChannelListenTopic, builder.build().toByteArray(), result -> {
+                    ErrorCode errorCode = ErrorCode.fromCode(result[0]);
+                    if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
+                        return new Result(ErrorCode.ERROR_CODE_SUCCESS);
+                    } else {
+                        return new Result(errorCode);
+                    }
+                });
+                return false;
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/admin/CheckUserOnlineAction.java

@@ -36,7 +36,7 @@ public class CheckUserOnlineAction extends AdminAction {
             InputGetUserInfo inputUserId = getRequestBody(request.getNettyRequest(), InputGetUserInfo.class);
             if (inputUserId == null || !StringUtil.isNullOrEmpty(inputUserId.getUserId())) {
                 sendApiMessage(response, inputUserId.getUserId(), ServerAPIHelper.CHECK_USER_ONLINE_REQUEST, inputUserId.getUserId().getBytes(), res -> {
-                    OutputCheckUserOnline out = new Gson().fromJson(new String(res), OutputCheckUserOnline.class);
+                    OutputCheckUserOnline out = gson.fromJson(new String(res), OutputCheckUserOnline.class);
                     return new Result(ErrorCode.ERROR_CODE_SUCCESS, out);
                 });
                 return false;

broker/src/main/java/com/xiaoleilu/loServer/action/admin/CheckUserSubscribeChannelAction.java

@@ -0,0 +1,52 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputChannelId;
+import cn.wildfirechat.pojos.InputSubscribeChannel;
+import cn.wildfirechat.pojos.OutputBooleanValue;
+import cn.wildfirechat.pojos.OutputGetChannelInfo;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+@Route(APIPath.Check_User_Subscribe_Channel)
+@HttpMethod("POST")
+public class CheckUserSubscribeChannelAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputSubscribeChannel inputSubscribeChannel = getRequestBody(request.getNettyRequest(), InputSubscribeChannel.class);
+            if (inputSubscribeChannel != null
+                && !StringUtil.isNullOrEmpty(inputSubscribeChannel.getChannelId())
+                && !StringUtil.isNullOrEmpty(inputSubscribeChannel.getUserId())) {
+                boolean isInChannel = messagesStore.checkUserInChannel(inputSubscribeChannel.getUserId(), inputSubscribeChannel.getChannelId());
+                OutputBooleanValue outputBooleanValue = new OutputBooleanValue();
+                outputBooleanValue.value = isInChannel;
+                setResponseContent(RestResult.ok(outputBooleanValue), response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/admin/CreateChatroomAction.java

@@ -39,7 +39,7 @@ public class CreateChatroomAction extends AdminAction {
             FullHttpRequest fullHttpRequest = (FullHttpRequest)request.getNettyRequest();
             byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
             String content = new String(bytes);
-            Gson gson = new Gson();
+            
             InputCreateChatroom inputCreateChatroom = gson.fromJson(content, InputCreateChatroom.class);
             if (inputCreateChatroom != null
                 && !StringUtil.isNullOrEmpty(inputCreateChatroom.getTitle())) {

broker/src/main/java/com/xiaoleilu/loServer/action/admin/CreateRobotAction.java

@@ -67,7 +67,7 @@ public class CreateRobotAction extends AdminAction {
                     Utility.printExecption(LOG, e, IMExceptionEvent.EventType.ADMIN_API_Exception);
                     response.setStatus(HttpResponseStatus.OK);
                     RestResult result = RestResult.resultOf(ErrorCode.ERROR_CODE_SERVER_ERROR, e.getMessage());
-                    response.setContent(new Gson().toJson(result));
+                    response.setContent(gson.toJson(result));
                     return true;
                 }
 

broker/src/main/java/com/xiaoleilu/loServer/action/admin/DestoryChatroomAction.java

@@ -37,7 +37,7 @@ public class DestoryChatroomAction extends AdminAction {
             FullHttpRequest fullHttpRequest = (FullHttpRequest)request.getNettyRequest();
             byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
             String content = new String(bytes);
-            Gson gson = new Gson();
+            
             InputDestoryChatroom inputDestoryChatroom = gson.fromJson(content, InputDestoryChatroom.class);
             if (inputDestoryChatroom != null
                 && !StringUtil.isNullOrEmpty(inputDestoryChatroom.getChatroomId())) {

broker/src/main/java/com/xiaoleilu/loServer/action/admin/GetCommonGroupsAction.java

@@ -0,0 +1,55 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputUserId;
+import cn.wildfirechat.pojos.OutputGroupIds;
+import cn.wildfirechat.pojos.StringPairPojo;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+import java.util.ArrayList;
+import java.util.Set;
+
+@Route(APIPath.Get_Common_Groups)
+@HttpMethod("POST")
+public class GetCommonGroupsAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            StringPairPojo input = getRequestBody(request.getNettyRequest(), StringPairPojo.class);
+            if (input != null
+                && (!StringUtil.isNullOrEmpty(input.getFirst())) && (!StringUtil.isNullOrEmpty(input.getSecond()))) {
+
+                Set<String> groupIds = messagesStore.getCommonGroupIds(input.getFirst(), input.getSecond());
+                OutputGroupIds outputGroupIds = new OutputGroupIds();
+                outputGroupIds.setGroupIds(new ArrayList<>(groupIds));
+                RestResult result = RestResult.ok(outputGroupIds);
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/admin/GetGroupMembersAction.java

@@ -63,6 +63,7 @@ public class GetGroupMembersAction extends AdminAction {
                         pm.setAlias(member.getAlias());
                         pm.setType(member.getType());
                         pm.setExtra(member.getExtra());
+                        pm.setCreateDt(member.getCreateDt());
                         out.getMembers().add(pm);
                     }
                     result = RestResult.ok(out);

broker/src/main/java/com/xiaoleilu/loServer/action/admin/GetMessageAction.java

@@ -0,0 +1,56 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputMessageUid;
+import cn.wildfirechat.pojos.OutputMessageData;
+import cn.wildfirechat.pojos.RecallMessageData;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+import win.liyufan.im.IMTopic;
+
+@Route(APIPath.Msg_GetOne)
+@HttpMethod("POST")
+public class GetMessageAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputMessageUid inputMessageUid = getRequestBody(request.getNettyRequest(), InputMessageUid.class);
+            if (inputMessageUid != null && inputMessageUid.messageUid > 0) {
+                RestResult result;
+                WFCMessage.Message msg = messagesStore.getMessage(inputMessageUid.messageUid);
+                if(msg == null) {
+                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
+                } else {
+                    result = RestResult.ok(OutputMessageData.fromProtoMessage(msg));
+                }
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/admin/GetRobotAction.java

@@ -0,0 +1,63 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.admin;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputGetUserInfo;
+import cn.wildfirechat.pojos.InputOutputUserInfo;
+import cn.wildfirechat.pojos.InputRobotId;
+import cn.wildfirechat.pojos.OutputRobot;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+@Route(APIPath.User_Get_Robot_Info)
+@HttpMethod("POST")
+public class GetRobotAction extends AdminAction {
+
+    @Override
+    public boolean isTransactionAction() {
+        return true;
+    }
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputRobotId inputUserId = getRequestBody(request.getNettyRequest(), InputRobotId.class);
+            if (inputUserId != null
+                && (!StringUtil.isNullOrEmpty(inputUserId.getRobotId()))) {
+
+                WFCMessage.User user = messagesStore.getUserInfo(inputUserId.getRobotId());
+                WFCMessage.Robot robot = messagesStore.getRobot(inputUserId.getRobotId());
+
+                RestResult result;
+                if (user == null || robot == null) {
+                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
+                } else {
+                    OutputRobot outputRobot = new OutputRobot();
+                    outputRobot.fromUser(user);
+                    outputRobot.fromRobot(robot, true);
+                    result = RestResult.ok(outputRobot);
+                }
+
+                setResponseContent(result, response);
+            } else {
+                setResponseContent(RestResult.resultOf(ErrorCode.INVALID_PARAMETER), response);
+            }
+
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/admin/GetUserAction.java

@@ -49,7 +49,7 @@ public class GetUserAction extends AdminAction {
                 }
 
                 RestResult result;
-                if (user == null) {
+                if (user == null || user.getDeleted() > 0) {
                     result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
                 } else {
                     result = RestResult.ok(InputOutputUserInfo.fromPbUser(user));

broker/src/main/java/com/xiaoleilu/loServer/action/admin/ModifyGroupMemberExtraAction.java

@@ -50,7 +50,7 @@ public class ModifyGroupMemberExtraAction extends AdminAction {
             } else {
                 response.setStatus(HttpResponseStatus.OK);
                 RestResult result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
-                response.setContent(new Gson().toJson(result));
+                response.setContent(gson.toJson(result));
             }
         }
         return true;

broker/src/main/java/com/xiaoleilu/loServer/action/channel/ApplicationGetUserInfoAction.java

@@ -0,0 +1,59 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.channel;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputApplicationGetUserInfo;
+import cn.wildfirechat.pojos.OutputApplicationUserInfo;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import com.google.gson.Gson;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.util.internal.StringUtil;
+
+@Route(APIPath.Channel_Application_Get_UserInfo)
+@HttpMethod("POST")
+public class ApplicationGetUserInfoAction extends ChannelAction {
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputApplicationGetUserInfo inputUserToken = getRequestBody(request.getNettyRequest(), InputApplicationGetUserInfo.class);
+            RestResult result;
+            if (inputUserToken == null || StringUtil.isNullOrEmpty(inputUserToken.getAuthCode())) {
+                result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
+            } else {
+                String userId = messagesStore.verifyApplicationAuthCode(inputUserToken.getAuthCode(), channelInfo.getTargetId(), ProtoConstants.ApplicationType.ApplicationType_Channel);
+                if(userId != null) {
+                    OutputApplicationUserInfo outputVerifyApplicationUser = new OutputApplicationUserInfo();
+                    outputVerifyApplicationUser.setUserId(userId);
+                    WFCMessage.User user = messagesStore.getUserInfo(userId);
+                    if(user != null) {
+                        outputVerifyApplicationUser.setDisplayName(user.getDisplayName());
+                        outputVerifyApplicationUser.setPortraitUrl(user.getPortrait());
+                    }
+                    result = RestResult.ok(outputVerifyApplicationUser);
+                } else {
+                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_APPLICATION_TOKEN_ERROR_OR_TIMEOUT);
+                }
+            }
+
+            response.setStatus(HttpResponseStatus.OK);
+            response.setContent(gson.toJson(result));
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/channel/ChannelAction.java

@@ -70,6 +70,7 @@ abstract public class ChannelAction extends Action {
         try {
             ts = Long.parseLong(timestamp);
         } catch (Exception e) {
+            LOG.error("Channel timestamp:{} invalid", timestamp);
             e.printStackTrace();
             Utility.printExecption(LOG, e, IMExceptionEvent.EventType.CHANNEL_API_Exception);
             return ErrorCode.ERROR_CODE_API_NOT_SIGNED;
@@ -81,7 +82,7 @@ abstract public class ChannelAction extends Action {
 
         channelInfo = messagesStore.getChannelInfo(cid);
         if (channelInfo == null) {
-            return ErrorCode.INVALID_PARAMETER;
+            return ErrorCode.ERROR_CODE_CHANNEL_NO_EXIST;
         }
         
         if (StringUtil.isNullOrEmpty(channelInfo.getSecret())) {
@@ -100,7 +101,7 @@ abstract public class ChannelAction extends Action {
         }
 
         RestResult result = RestResult.resultOf(errorCode, errorCode.getMsg(), data);
-        response.setContent(new Gson().toJson(result));
+        response.setContent(gson.toJson(result));
         response.send();
     }
 
@@ -109,7 +110,7 @@ abstract public class ChannelAction extends Action {
             FullHttpRequest fullHttpRequest = (FullHttpRequest) request;
             byte[] bytes = Utils.readBytesAndRewind(fullHttpRequest.content());
             String content = new String(bytes, StandardCharsets.UTF_8);
-            Gson gson = new Gson();
+            
             T t = gson.fromJson(content, cls);
             return t;
         }

broker/src/main/java/com/xiaoleilu/loServer/action/channel/GetIsChannelSubscriberAction.java

@@ -0,0 +1,37 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.channel;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.pojos.InputChannelSubscribe;
+import cn.wildfirechat.pojos.InputUserId;
+import cn.wildfirechat.pojos.OutputStringList;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+
+import java.util.ArrayList;
+
+@Route(APIPath.Channel_Is_Subscriber)
+@HttpMethod("POST")
+public class GetIsChannelSubscriberAction extends ChannelAction {
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputUserId input = getRequestBody(request.getNettyRequest(), InputUserId.class);
+            boolean isSubscriber = messagesStore.checkUserInChannel(input.getUserId(), channelInfo.getTargetId());
+            setResponseContent(RestResult.ok(isSubscriber), response);
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/channel/GetUserAction.java

@@ -14,16 +14,12 @@ import cn.wildfirechat.pojos.InputGetUserInfo;
 import cn.wildfirechat.pojos.InputOutputUserInfo;
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
-import com.google.gson.Gson;
 import com.xiaoleilu.loServer.RestResult;
-import com.xiaoleilu.loServer.action.admin.AdminAction;
-import com.xiaoleilu.loServer.action.robot.RobotAction;
 import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
 import com.xiaoleilu.loServer.handler.Request;
 import com.xiaoleilu.loServer.handler.Response;
 import io.netty.handler.codec.http.FullHttpRequest;
-import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.util.internal.StringUtil;
 
 @Route(APIPath.Channel_User_Info)
@@ -48,7 +44,7 @@ public class GetUserAction extends ChannelAction {
 
                 RestResult result;
 
-                if (user == null || StringUtil.isNullOrEmpty(user.getName())) {
+                if (user == null || StringUtil.isNullOrEmpty(user.getName()) || user.getDeleted() > 0) {
                     result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
                 } else {
                     if (channelInfo.getOwner().equals(inputUserId.getUserId()) ||

broker/src/main/java/com/xiaoleilu/loServer/action/channel/SendMessageAction.java

@@ -12,7 +12,6 @@ package com.xiaoleilu.loServer.action.channel;
 import cn.wildfirechat.common.APIPath;
 import cn.wildfirechat.pojos.SendChannelMessageData;
 import cn.wildfirechat.proto.ProtoConstants;
-import com.google.gson.Gson;
 import com.xiaoleilu.loServer.RestResult;
 import com.xiaoleilu.loServer.annotation.HttpMethod;
 import com.xiaoleilu.loServer.annotation.Route;
@@ -24,7 +23,6 @@ import cn.wildfirechat.pojos.SendMessageResult;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.http.FullHttpRequest;
-import io.netty.handler.codec.http.HttpResponseStatus;
 import cn.wildfirechat.common.ErrorCode;
 import win.liyufan.im.IMTopic;
 

broker/src/main/java/com/xiaoleilu/loServer/action/channel/SubscriberChannelAction.java

@@ -38,7 +38,7 @@ public class SubscriberChannelAction extends ChannelAction {
                 if(input.getSubscribe() > 0 && (channelInfo.getStatus() & ProtoConstants.ChannelState.Channel_State_Mask_Active_Subscribe) == 0) {
                     response.setStatus(HttpResponseStatus.OK);
                     RestResult result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_RIGHT);
-                    response.setContent(new Gson().toJson(result));
+                    response.setContent(gson.toJson(result));
                     return true;
                 }
                 WFCMessage.ListenChannel listenChannel = WFCMessage.ListenChannel.newBuilder().setChannelId(channelInfo.getTargetId()).setListen(input.getSubscribe()).build();

broker/src/main/java/com/xiaoleilu/loServer/action/robot/ApplicationGetUserInfoAction.java

@@ -0,0 +1,59 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.robot;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputApplicationGetUserInfo;
+import cn.wildfirechat.pojos.OutputApplicationUserInfo;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import com.google.gson.Gson;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.util.internal.StringUtil;
+
+@Route(APIPath.Robot_Application_Get_UserInfo)
+@HttpMethod("POST")
+public class ApplicationGetUserInfoAction extends RobotAction {
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            InputApplicationGetUserInfo inputUserToken = getRequestBody(request.getNettyRequest(), InputApplicationGetUserInfo.class);
+            RestResult result;
+            if (inputUserToken == null || StringUtil.isNullOrEmpty(inputUserToken.getAuthCode())) {
+                result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
+            } else {
+                String userId = messagesStore.verifyApplicationAuthCode(inputUserToken.getAuthCode(), robot.getUid(), ProtoConstants.ApplicationType.ApplicationType_Robot);
+                if(userId != null) {
+                    OutputApplicationUserInfo outputVerifyApplicationUser = new OutputApplicationUserInfo();
+                    outputVerifyApplicationUser.setUserId(userId);
+                    WFCMessage.User user = messagesStore.getUserInfo(userId);
+                    if(user != null) {
+                        outputVerifyApplicationUser.setDisplayName(user.getDisplayName());
+                        outputVerifyApplicationUser.setPortraitUrl(user.getPortrait());
+                    }
+                    result = RestResult.ok(outputVerifyApplicationUser);
+                } else {
+                    result = RestResult.resultOf(ErrorCode.ERROR_CODE_APPLICATION_TOKEN_ERROR_OR_TIMEOUT);
+                }
+            }
+
+            response.setStatus(HttpResponseStatus.OK);
+            response.setContent(gson.toJson(result));
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/robot/GetGroupMembersAction.java

@@ -67,6 +67,7 @@ public class GetGroupMembersAction extends RobotAction {
                         pm.setAlias(member.getAlias());
                         pm.setType(member.getType());
                         pm.setExtra(member.getExtra());
+                        pm.setCreateDt(member.getCreateDt());
                         out.getMembers().add(pm);
                     }
                     if(!isInGroup) {

broker/src/main/java/com/xiaoleilu/loServer/action/robot/GetProfileAction.java

@@ -0,0 +1,46 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package com.xiaoleilu.loServer.action.robot;
+
+import cn.wildfirechat.common.APIPath;
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.pojos.InputGetUserInfo;
+import cn.wildfirechat.pojos.InputOutputUserInfo;
+import cn.wildfirechat.pojos.OutputRobot;
+import cn.wildfirechat.proto.WFCMessage;
+import com.xiaoleilu.loServer.RestResult;
+import com.xiaoleilu.loServer.annotation.HttpMethod;
+import com.xiaoleilu.loServer.annotation.Route;
+import com.xiaoleilu.loServer.handler.Request;
+import com.xiaoleilu.loServer.handler.Response;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.util.internal.StringUtil;
+
+@Route(APIPath.Robot_Get_Profile)
+@HttpMethod("POST")
+public class GetProfileAction extends RobotAction {
+
+    @Override
+    public boolean action(Request request, Response response) {
+        if (request.getNettyRequest() instanceof FullHttpRequest) {
+            WFCMessage.User user = messagesStore.getUserInfo(robot.getUid());
+            RestResult result;
+            if (user == null) {
+                result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
+            } else {
+                OutputRobot outputRobot = new OutputRobot();
+                outputRobot.fromUser(user);
+                outputRobot.fromRobot(robot, false);
+                result = RestResult.ok(outputRobot);
+            }
+            setResponseContent(result, response);
+        }
+        return true;
+    }
+}

broker/src/main/java/com/xiaoleilu/loServer/action/robot/GetUserAction.java

@@ -44,7 +44,7 @@ public class GetUserAction extends RobotAction {
                 }
 
                 RestResult result;
-                if (user == null) {
+                if (user == null || user.getDeleted() > 0) {
                     result = RestResult.resultOf(ErrorCode.ERROR_CODE_NOT_EXIST);
                 } else {
                     result = RestResult.ok(InputOutputUserInfo.fromPbUser(user));

broker/src/main/java/com/xiaoleilu/loServer/action/robot/ModifyGroupMemberExtraAction.java

@@ -53,7 +53,7 @@ public class ModifyGroupMemberExtraAction extends RobotAction {
             } else {
                 response.setStatus(HttpResponseStatus.OK);
                 RestResult result = RestResult.resultOf(ErrorCode.INVALID_PARAMETER);
-                response.setContent(new Gson().toJson(result));
+                response.setContent(gson.toJson(result));
             }
         }
         return true;

broker/src/main/java/com/xiaoleilu/loServer/action/robot/RobotAction.java

@@ -102,7 +102,7 @@ abstract public class RobotAction extends Action {
         }
 
         RestResult result = RestResult.resultOf(errorCode, errorCode.getMsg(), data);
-        response.setContent(new Gson().toJson(result));
+        response.setContent(gson.toJson(result));
         response.send();
     }
 
@@ -113,7 +113,7 @@ abstract public class RobotAction extends Action {
             String content = null;
             try {
                 content = new String(bytes, "UTF-8");
-                Gson gson = new Gson();
+                
                 T t = gson.fromJson(content, cls);
                 return t;
             } catch (UnsupportedEncodingException e) {

broker/src/main/java/com/xiaoleilu/loServer/handler/ActionHandler.java

@@ -15,6 +15,7 @@ import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.handler.codec.http.FullHttpRequest;
 import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.util.internal.StringUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import win.liyufan.im.Utility;
@@ -34,7 +35,6 @@ abstract public class ActionHandler extends SimpleChannelInboundHandler<FullHttp
 
     @Override
 	protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest fullHttpRequest) throws Exception {
-        Logger.info("Http request whit url {}", fullHttpRequest.uri());
 		final Request request = Request.build(ctx, fullHttpRequest);
 		final Response response = Response.build(ctx, request);
 
@@ -109,14 +109,24 @@ abstract public class ActionHandler extends SimpleChannelInboundHandler<FullHttp
 	 * @param response 响应对象
 	 */
 	private void doAction(ChannelHandlerContext ctx, Request request, Response response){
-	    if(("/route".equalsIgnoreCase(request.getPath()) || request.getPath().startsWith("/fs/"))
+	    if(("/route".equalsIgnoreCase(request.getPath()) || (!StringUtil.isNullOrEmpty(request.getPath()) && request.getPath().startsWith("/fs/")))
             && "OPTIONS".equalsIgnoreCase(request.getMethod())){
 	        handleOptions(ctx, request, response);
 	        return;
         }
+
+        if ("HEAD".equalsIgnoreCase(request.getMethod())) {
+            response.setStatus(HttpResponseStatus.OK);
+            response.send();
+            return;
+        }
+
 		Action action;
 		if (isValidePath(request.getPath())) {
             action = ServerSetting.getAction(request.getPath(), request.getMethod().toUpperCase());
+            if (action != null) {
+                Logger.info("Http request whit url {}", request.getPath());
+            }
         } else {
             action = ServerSetting.getErrorAction(ServerSetting.MAPPING_ERROR);
         }
@@ -130,7 +140,11 @@ abstract public class ActionHandler extends SimpleChannelInboundHandler<FullHttp
 			action = ServerSetting.getAction(ServerSetting.MAPPING_ALL, request.getMethod());
 			if(null == action){
 				// 非Action方法，调用静态文件读取
-				action = Singleton.get(FileAction.class);
+                if(request.getPath().startsWith("/fs")) {
+                    action = Singleton.get(FileAction.class);
+                } else {
+                    action = ServerSetting.getErrorAction(ServerSetting.MAPPING_ERROR);
+                }
 			}
 		}
         action.ctx = ctx;

broker/src/main/java/com/xiaoleilu/loServer/handler/Request.java

@@ -81,18 +81,6 @@ public class Request {
 
 		// request URI parameters
 		this.putParams(new QueryStringDecoder(uri));
-		if(nettyRequest.method() != HttpMethod.GET){
-			HttpPostRequestDecoder decoder = null;
-			try {
-				decoder = new HttpPostRequestDecoder(HTTP_DATA_FACTORY, nettyRequest);
-				this.putParams(decoder);
-			} finally {
-				if(null != decoder){
-					decoder.destroy();
-					decoder = null;
-				}
-			}
-		}
 
 		// IP
 		this.putIp(ctx);

broker/src/main/java/com/xiaoleilu/loServer/handler/Response.java

@@ -41,6 +41,7 @@ import io.netty.handler.codec.http.LastHttpContent;
 import io.netty.handler.codec.http.cookie.Cookie;
 import io.netty.handler.codec.http.cookie.DefaultCookie;
 import io.netty.handler.codec.http.cookie.ServerCookieEncoder;
+import org.apache.tika.Tika;
 import org.slf4j.LoggerFactory;
 
 /**
@@ -469,7 +470,9 @@ public class Response {
 		this.setContentLength(fileLength);
 		
 		//文件类型
-		String contentType = HttpUtil.getMimeType(file.getName());
+        Tika tika = new Tika();
+        String contentType = tika.detect(file);
+//		String contentType = HttpUtil.getMimeType(file.getName());
 		if(StrUtil.isBlank(contentType)){
 			//无法识别默认使用数据流
 			contentType = "application/octet-stream";

broker/src/main/java/io/moquette/BrokerConstants.java

@@ -110,8 +110,13 @@ public final class BrokerConstants {
     public static final String TOKEN_SECRET_KEY = "token.key";
     public static final String TOKEN_EXPIRE_TIME = "token.expire_time";
 
+    public static final String CONNECT_CLIENT_SIGNATURE_LIST = "connect.client_signature_list";
+    public static final String CONNECT_REJECT_EMPTY_SIGNATURE = "connect.reject_empty_signature";
+
     public static final String EMBED_DB_PROPERTY_NAME = "embed.db";
     public static final String DB_AUTO_CLEAN_HISTORY_MESSAGES = "db.auto_clean_history_messages";
+    public static final String H2DB_PATH = "h2db.path";
+
 
     public static final String SENSITIVE_Filter_Type = "sensitive.filter.type";
 
@@ -120,34 +125,42 @@ public final class BrokerConstants {
     public static final String SENSITIVE_Remote_Fail_When_Matched = "sensitive.remote_fail_when_matched";
 
     public static final String MESSAGE_Forward_Url = "message.forward.url";
+    public static final String MESSAGE_Sensitive_Forward_Url = "message.sensitive.forward.url";
     public static final String MESSAGE_Forward_Types = "message.forward.types";
+    public static final String MESSAGE_Forward_Exclude_Types = "message.forward.exclude_types";
     public static final String MESSAGE_MentionMsg_Forward_Url = "message.mentionmsg.forward.url";
-
+    public static final String MESSAGE_RecallMsg_Forward_Url = "message.recallmsg.forward.url";
 
     public static final String SERVER_MULTI_ENDPOINT = "server.multi_endpoint";
+    public static final String SERVER_MULTI_PC_ENDPOINT = "server.multi_pc_endpoint";
     public static final String SERVER_MULTI_PLATFROM_NOTIFICATION = "server.multi_platform_notification";
     public static final String SERVER_MOBILE_DEFAULT_SILENT_WHEN_PC_ONLINE = "server.mobile_default_silent_when_pc_online";
     public static final String SERVER_CLIENT_SUPPORT_KICKOFF_EVENT = "server.client_support_kickoff_event";
 
     public static final String MESSAGE_ROAMING = "message.roaming";
+    public static final String MESSAGE_Compensate_Time_Limit = "message.compensate_time_limit";
     public static final String MESSAGE_Remote_History_Message = "message.remote_history_message";
     public static final String MESSAGE_Remote_Chatroom_History_Message = "message.chatroom_remote_history_message";
 
     public static final String MESSAGE_Max_Queue = "message.max_queue";
 
     public static final String MESSAGE_Disable_Stranger_Chat = "message.disable_stranger_chat";
+    public static final String MESSAGE_Allow_Stranger_Chat_List = "message.allow_stranger_chat_list";
 
     public static final String MESSAGE_Blacklist_Strategy = "message.blacklist.strategy";
 
     public static final String MESSAGE_NO_Forward_Admin_Message = "message.no_forward_admin_message";
 
+    public static final String MESSAGE_Forward_With_Client_Info = "message.forward_with_client_info";
+    public static final String ROBOT_Callback_With_Client_Info = "robot.callback_with_client_info";
+    public static final String CHANNEL_Callback_With_Client_Info = "channel.callback_with_client_info";
+
     public static final String FRIEND_Disable_Search = "friend.disable_search";
     public static final String FRIEND_Disable_NickName_Search = "friend.disable_nick_name_search";
     public static final String FRIEND_Disable_Friend_Request = "friend.disable_friend_request";
     public static final String FRIEND_Repeat_Request_Duration = "friend.repeat_request_duration";
     public static final String FRIEND_Reject_Request_Duration = "friend.reject_request_duration";
     public static final String FRIEND_Request_Expiration_Duration = "friend.request_expiration_duration";
-    public static final String FRIEND_New_Welcome_Message = "friend.new_welcome_message";
 
     public static final String CHATROOM_Participant_Idle_Time = "chatroom.participant_idle_time";
     public static final String CHATROOM_Rejoin_When_Active = "chatroom.rejoin_when_active";
@@ -158,8 +171,11 @@ public final class BrokerConstants {
     public static final String GROUP_Allow_Robot_Custom_Operation_Notification = "group.allow_robot_custom_operation_notificatio";
 
     public static final String GROUP_Visible_Quit_Kickoff_Notification = "group.visible_quit_or_kickoff_notification";
+    public static final String GROUP_Forbidden_Client_Operation = "group.forbidden_client_operation";
 
     public static final String USER_HIDE_PROPERTIES = "user.hide_properties";
+    public static final String USER_KEEP_DISPLAY_NAME_WHEN_DESTROY = "user.keep_display_name_when_destroy";
+
     public static final String SYNC_Data_Part_Size = "sync.data_part_size";
 
     public static final String MESSAGES_FORBIDDEN_CLIENT_SEND_TYPES = "message.forbidden_client_send_types";

broker/src/main/java/io/moquette/imhandler/AddGroupMember.java

@@ -24,6 +24,20 @@ public class AddGroupMember extends GroupHandler<WFCMessage.AddGroupMemberReques
     @Override
     public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.AddGroupMemberRequest request, Qos1PublishHandler.IMCallback callback) {
         boolean isAdmin = requestSourceType == ProtoConstants.RequestSourceType.Request_From_Admin;
+
+        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
+            int forbiddenClientOperation = m_messagesStore.getGroupForbiddenClientOperation();
+            if(request.getAddedMemberList().size() == 1 && request.getAddedMember(0).getMemberId().equals(fromUser)) {
+                if ((forbiddenClientOperation & ProtoConstants.ForbiddenClientGroupOperationMask.Forbidden_Join_Group) > 0) {
+                    return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                }
+            } else {
+                if ((forbiddenClientOperation & ProtoConstants.ForbiddenClientGroupOperationMask.Forbidden_Invite_Group_Member) > 0) {
+                    return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                }
+            }
+        }
+
         ErrorCode errorCode = m_messagesStore.addGroupMembers(fromUser, isAdmin, request.getGroupId(), request.getAddedMemberList(), request.getExtra());
         if (errorCode == ERROR_CODE_SUCCESS) {
             if (request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {

broker/src/main/java/io/moquette/imhandler/ChannelListenMember.java

@@ -27,8 +27,6 @@ public class ChannelListenMember extends IMHandler<WFCMessage.ListenChannel> {
         if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
             WFCMessage.ModifyUserSettingReq modifyUserSettingReq = WFCMessage.ModifyUserSettingReq.newBuilder().setScope(kUserSettingListenedChannels).setKey(request.getChannelId()).setValue(request.getListen() > 0 ? "1" : "0").build();
             mServer.onApiMessage(fromUser, null, modifyUserSettingReq.toByteArray(), 0, fromUser, PutUserSettingTopic, requestSourceType);
-
-            publisher.notifyChannelListenStatusChanged(m_messagesStore.getChannelInfo(request.getChannelId()), fromUser, request.getListen() > 0);
         }
         return errorCode;
     }

broker/src/main/java/io/moquette/imhandler/ConfigApplicationHandler.java

@@ -0,0 +1,28 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package io.moquette.imhandler;
+
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import io.moquette.spi.impl.Qos1PublishHandler;
+import io.netty.buffer.ByteBuf;
+import win.liyufan.im.IMTopic;
+
+import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
+
+@Handler(IMTopic.ApplicationConfigRequestTopic)
+public class ConfigApplicationHandler extends IMHandler<WFCMessage.ApplicationConfigRequest> {
+    @Override
+    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.ApplicationConfigRequest request, Qos1PublishHandler.IMCallback callback) {
+        ErrorCode errorCode = m_messagesStore.configApplication(request.getAppId(), request.getAppType(), request.getTimestamp(), request.getNonce(), request.getSignature());
+        return errorCode;
+    }
+}
+

broker/src/main/java/io/moquette/imhandler/CreateGroupHandler.java

@@ -21,6 +21,9 @@ import win.liyufan.im.IMTopic;
 public class CreateGroupHandler extends GroupHandler<WFCMessage.CreateGroupRequest> {
     @Override
     public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.CreateGroupRequest request, Qos1PublishHandler.IMCallback callback) {
+        if(request.getGroup().getGroupInfo().getType() < 0 || request.getGroup().getGroupInfo().getType() > 3) {
+            return ErrorCode.ERROR_CODE_INVALID_DATA;
+        }
 
         if (!StringUtil.isNullOrEmpty(request.getGroup().getGroupInfo().getTargetId())) {
             WFCMessage.GroupInfo existGroupInfo = m_messagesStore.getGroupInfo(request.getGroup().getGroupInfo().getTargetId());
@@ -37,6 +40,16 @@ public class CreateGroupHandler extends GroupHandler<WFCMessage.CreateGroupReque
             return ErrorCode.ERROR_CODE_NOT_RIGHT;
         }
 
+        if(!isAdmin && request.getGroup().getGroupInfo().getType() == ProtoConstants.GroupType.GroupType_Organization) {
+            return ErrorCode.ERROR_CODE_NOT_RIGHT;
+        }
+
+        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
+            int forbiddenClientOperation = m_messagesStore.getGroupForbiddenClientOperation();
+            if((forbiddenClientOperation & ProtoConstants.ForbiddenClientGroupOperationMask.Forbidden_Create_Group) > 0) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+        }
         WFCMessage.GroupInfo groupInfo = m_messagesStore.createGroup(fromUser, request.getGroup().getGroupInfo(), request.getGroup().getMembersList(), request.getMemberExtra(), isAdmin);
         if (groupInfo != null) {
             if(request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {

broker/src/main/java/io/moquette/imhandler/DestroyChannelHandler.java

@@ -19,11 +19,11 @@ import static win.liyufan.im.IMTopic.PutUserSettingTopic;
 import static win.liyufan.im.UserSettingScope.kUserSettingMyChannels;
 
 @Handler(value = IMTopic.DestroyChannelInfoTopic)
-public class DistroyChannelHandler extends GroupHandler<WFCMessage.IDBuf> {
+public class DestroyChannelHandler extends GroupHandler<WFCMessage.IDBuf> {
     @Override
     public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.IDBuf request, Qos1PublishHandler.IMCallback callback) {
         boolean isAdmin = requestSourceType == ProtoConstants.RequestSourceType.Request_From_Admin;
-        ErrorCode errorCode = m_messagesStore.distoryChannel(fromUser, request.getId(), isAdmin);
+        ErrorCode errorCode = m_messagesStore.destroyChannel(fromUser, request.getId(), isAdmin);
         if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
             WFCMessage.ModifyUserSettingReq modifyUserSettingReq = WFCMessage.ModifyUserSettingReq.newBuilder().setScope(kUserSettingMyChannels).setKey(request.getId()).setValue("0").build();
             mServer.onApiMessage(fromUser, null, modifyUserSettingReq.toByteArray(), 0, fromUser, PutUserSettingTopic, requestSourceType);

broker/src/main/java/io/moquette/imhandler/DestroyUserHandler.java

@@ -11,9 +11,7 @@ package io.moquette.imhandler;
 import cn.wildfirechat.common.ErrorCode;
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
-import io.moquette.persistence.MemorySessionStore;
 import io.moquette.spi.impl.Qos1PublishHandler;
-import io.moquette.spi.impl.security.TokenAuthenticator;
 import io.netty.buffer.ByteBuf;
 import win.liyufan.im.IMTopic;
 
@@ -30,7 +28,7 @@ public class DestroyUserHandler extends IMHandler<WFCMessage.IDBuf> {
                 m_messagesStore.clearUserFriend(fromUser);
                 m_messagesStore.clearUserGroups(fromUser);
                 m_messagesStore.clearUserChannels(fromUser);
-                m_messagesStore.destoryUser(fromUser);
+                m_messagesStore.destroyUser(fromUser);
 
                 m_messagesStore.destroyRobot(fromUser);
             });

broker/src/main/java/io/moquette/imhandler/DismissGroupHandler.java

@@ -26,7 +26,6 @@ public class DismissGroupHandler extends GroupHandler<WFCMessage.DismissGroupReq
             ErrorCode errorCode;
             if (groupInfo == null) {
                 errorCode = m_messagesStore.dismissGroup(fromUser, request.getGroupId(), isAdmin);
-
             } else if (isAdmin || (groupInfo.getType() == ProtoConstants.GroupType.GroupType_Normal || groupInfo.getType() == ProtoConstants.GroupType.GroupType_Restricted)
                 && groupInfo.getOwner() != null && groupInfo.getOwner().equals(fromUser)) {
 
@@ -38,6 +37,13 @@ public class DismissGroupHandler extends GroupHandler<WFCMessage.DismissGroupReq
                     return ErrorCode.ERROR_CODE_NOT_RIGHT;
                 }
 
+                if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
+                    int forbiddenClientOperation = m_messagesStore.getGroupForbiddenClientOperation();
+                    if((forbiddenClientOperation & ProtoConstants.ForbiddenClientGroupOperationMask.Forbidden_Dismiss_Group) > 0) {
+                        return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                    }
+                }
+
                 //send notify message first, then dismiss group
                 if (request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {
                     sendGroupNotification(fromUser, groupInfo.getTargetId(), request.getToLineList(), request.getNotifyContent());

broker/src/main/java/io/moquette/imhandler/GetApplicationTokenHandler.java

@@ -0,0 +1,33 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package io.moquette.imhandler;
+
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import io.moquette.spi.impl.Qos1PublishHandler;
+import io.netty.buffer.ByteBuf;
+import win.liyufan.im.IMTopic;
+
+import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
+
+@Handler(IMTopic.GetApplicationTokenRequestTopic)
+public class GetApplicationTokenHandler extends IMHandler<WFCMessage.AuthCodeRequest> {
+    @Override
+    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.AuthCodeRequest request, Qos1PublishHandler.IMCallback callback) {
+        String authCode = m_messagesStore.getApplicationAuthCode(fromUser, request.getTargetId(), request.getType(), request.getHost());
+        if(authCode != null) {
+            byte[] data = WFCMessage.IDBuf.newBuilder().setId(authCode).build().toByteArray();
+            ackPayload.ensureWritable(data.length).writeBytes(data);
+            return ERROR_CODE_SUCCESS;
+        }
+        return ErrorCode.INVALID_PARAMETER;
+
+    }
+}

broker/src/main/java/io/moquette/imhandler/GetCommonGroupsHandler.java

@@ -0,0 +1,33 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package io.moquette.imhandler;
+
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import io.moquette.spi.impl.Qos1PublishHandler;
+import io.netty.buffer.ByteBuf;
+import win.liyufan.im.IMTopic;
+
+import java.util.Set;
+
+import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
+
+@Handler(IMTopic.GetCommonGroupsTopic)
+public class GetCommonGroupsHandler extends IMHandler<WFCMessage.IDBuf> {
+    @Override
+    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.IDBuf request, Qos1PublishHandler.IMCallback callback) {
+        WFCMessage.PullUserResult.Builder resultBuilder = WFCMessage.PullUserResult.newBuilder();
+        Set<String> strings = m_messagesStore.getCommonGroupIds(fromUser, request.getId());
+        WFCMessage.IDListBuf idListBuf = WFCMessage.IDListBuf.newBuilder().addAllId(strings).build();
+        byte[] data = idListBuf.toByteArray();
+        ackPayload.ensureWritable(data.length).writeBytes(data);
+        return ERROR_CODE_SUCCESS;
+    }
+}

broker/src/main/java/io/moquette/imhandler/GetGroupInfoHandler.java

@@ -21,7 +21,7 @@ import java.util.List;
 public class GetGroupInfoHandler extends IMHandler<WFCMessage.PullUserRequest> {
     @Override
     public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.PullUserRequest request, Qos1PublishHandler.IMCallback callback) {
-            List<WFCMessage.GroupInfo> infos = m_messagesStore.getGroupInfos(request.getRequestList());
+            List<WFCMessage.GroupInfo> infos = m_messagesStore.getGroupInfos(request.getRequestList(), fromUser, requestSourceType == ProtoConstants.RequestSourceType.Request_From_Admin);
 
             WFCMessage.PullGroupInfoResult result = WFCMessage.PullGroupInfoResult.newBuilder().addAllInfo(infos).build();
             byte[] data = result.toByteArray();

broker/src/main/java/io/moquette/imhandler/GetMyGroupsHandler.java

@@ -0,0 +1,33 @@
+/*
+ * This file is part of the Wildfire Chat package.
+ * (c) Heavyrain2012 <heavyrain.lee@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+package io.moquette.imhandler;
+
+import cn.wildfirechat.common.ErrorCode;
+import cn.wildfirechat.proto.ProtoConstants;
+import cn.wildfirechat.proto.WFCMessage;
+import io.moquette.spi.impl.Qos1PublishHandler;
+import io.netty.buffer.ByteBuf;
+import win.liyufan.im.IMTopic;
+
+import java.util.Set;
+
+import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
+
+@Handler(IMTopic.GetMyGroupsTopic)
+public class GetMyGroupsHandler extends IMHandler<Void> {
+    @Override
+    public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, Void request, Qos1PublishHandler.IMCallback callback) {
+        WFCMessage.PullUserResult.Builder resultBuilder = WFCMessage.PullUserResult.newBuilder();
+        Set<String> strings = m_messagesStore.getUserGroupIds(fromUser);
+        WFCMessage.IDListBuf idListBuf = WFCMessage.IDListBuf.newBuilder().addAllId(strings).build();
+        byte[] data = idListBuf.toByteArray();
+        ackPayload.ensureWritable(data.length).writeBytes(data);
+        return ERROR_CODE_SUCCESS;
+    }
+}

broker/src/main/java/io/moquette/imhandler/GetQiniuUploadTokenHandler.java

@@ -26,6 +26,7 @@ public class GetQiniuUploadTokenHandler extends IMHandler<Byte> {
         String token;
 
         WFCMessage.GetUploadTokenResult.Builder resultBuilder = WFCMessage.GetUploadTokenResult.newBuilder();
+
         if (MediaServerConfig.USER_QINIU) {
             Auth auth = Auth.create(MediaServerConfig.QINIU_ACCESS_KEY, MediaServerConfig.QINIU_SECRET_KEY);
 

broker/src/main/java/io/moquette/imhandler/GroupHandler.java

@@ -43,7 +43,7 @@ abstract public class GroupHandler<T> extends IMHandler<T> {
             try {
                 long messageId = MessageShardingUtil.generateId();
                 builder.setMessageId(messageId);
-                saveAndPublish(fromUser, null, builder.build());
+                saveAndPublish(fromUser, null, builder.build(), ProtoConstants.RequestSourceType.Request_From_User);
             } catch (Exception e) {
                 e.printStackTrace();
             }

broker/src/main/java/io/moquette/imhandler/HandleFriendRequestHandler.java

@@ -10,12 +10,10 @@ package io.moquette.imhandler;
 
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
-import io.moquette.persistence.MemorySessionStore;
 import io.moquette.spi.impl.Qos1PublishHandler;
 import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import io.netty.util.internal.StringUtil;
-import win.liyufan.im.I18n;
 import win.liyufan.im.IMTopic;
 import win.liyufan.im.MessageShardingUtil;
 
@@ -28,7 +26,7 @@ public class HandleFriendRequestHandler extends IMHandler<WFCMessage.HandleFrien
     public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.HandleFriendRequest request, Qos1PublishHandler.IMCallback callback) {
             WFCMessage.Message.Builder builder = WFCMessage.Message.newBuilder();
             builder.setFromUser(request.getTargetUid());
-            long[] heads = new long[2];
+            long[] heads = new long[4];
             boolean isAdmin = requestSourceType == ProtoConstants.RequestSourceType.Request_From_Admin;
             ErrorCode errorCode = m_messagesStore.handleFriendRequest(fromUser, request, builder, heads, isAdmin);
 
@@ -40,20 +38,11 @@ public class HandleFriendRequestHandler extends IMHandler<WFCMessage.HandleFrien
                         builder.setMessageId(messageId);
                         builder.setServerTimestamp(timestamp);
                         if(!StringUtil.isNullOrEmpty(builder.getContent().getSearchableContent())) {
-                            saveAndPublish(request.getTargetUid(), null, builder.build());
+                            saveAndPublish(request.getTargetUid(), null, builder.build(), requestSourceType);
                         }
 
-                        MemorySessionStore.Session session = m_sessionsStore.getSession(clientID);
-                        String language = "zh_CN";
-                        if (session != null && !StringUtil.isNullOrEmpty(session.getLanguage())) {
-                            language = session.getLanguage();
-                        }
                         WFCMessage.MessageContent.Builder contentBuilder = WFCMessage.MessageContent.newBuilder();
-                        if (m_messagesStore.isNewFriendWelcomeMessage()) {
-                            contentBuilder.setType(92);
-                        } else {
-                            contentBuilder.setType(90).setContent(I18n.getString(language, "Above_Greeting_Message"));
-                        }
+                        contentBuilder.setType(92);
 
                         builder = WFCMessage.Message.newBuilder();
                         builder.setFromUser(request.getTargetUid());
@@ -63,19 +52,13 @@ public class HandleFriendRequestHandler extends IMHandler<WFCMessage.HandleFrien
 
                         messageId = MessageShardingUtil.generateId();
                         builder.setMessageId(messageId);
-                        saveAndPublish(request.getTargetUid(), null, builder.build());
-
-                        if (m_messagesStore.isNewFriendWelcomeMessage()) {
-                            contentBuilder.setType(93);
-                        } else {
-                            contentBuilder.setContent(I18n.getString(language, "Friend_Can_Start_Chat"));
-                        }
-
+                        saveAndPublish(request.getTargetUid(), null, builder.build(), requestSourceType);
+                        contentBuilder.setType(93);
                         builder.setContent(contentBuilder);
                         messageId = MessageShardingUtil.generateId();
                         builder.setMessageId(messageId);
                         builder.setServerTimestamp(++timestamp);
-                        saveAndPublish(request.getTargetUid(), null, builder.build());
+                        saveAndPublish(request.getTargetUid(), null, builder.build(), requestSourceType);
                     } catch (Exception e) {
                         e.printStackTrace();
                     }
@@ -84,6 +67,14 @@ public class HandleFriendRequestHandler extends IMHandler<WFCMessage.HandleFrien
                     publisher.publishNotification(IMTopic.NotifyFriendTopic, request.getTargetUid(), heads[0]);
                     publisher.publishNotification(IMTopic.NotifyFriendTopic, fromUser, heads[1]);
                 }
+                if(!isAdmin) {
+                    if(heads[2] > 0) {
+                        publisher.publishNotification(IMTopic.NotifyFriendRequestTopic, request.getTargetUid(), heads[2], fromUser, null);
+                    }
+                    if(heads[3] > 0) {
+                        publisher.publishNotification(IMTopic.NotifyFriendRequestTopic, fromUser, heads[3], fromUser, null);
+                    }
+                }
             }
             if(errorCode == ERROR_CODE_ALREADY_FRIENDS) {
                 errorCode = ERROR_CODE_SUCCESS;

broker/src/main/java/io/moquette/imhandler/IMHandler.java

@@ -25,6 +25,7 @@ import io.netty.util.internal.StringUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import cn.wildfirechat.common.ErrorCode;
+import win.liyufan.im.GsonUtil;
 import win.liyufan.im.RateLimiter;
 import win.liyufan.im.Utility;
 
@@ -39,6 +40,8 @@ import java.util.*;
 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_OVER_FREQUENCY;
 import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
 import static io.moquette.BrokerConstants.CLIENT_REQUEST_RATE_LIMIT;
+import static win.liyufan.im.IMTopic.GetUserSettingTopic;
+import static win.liyufan.im.IMTopic.PullMessageTopic;
 
 /**
  * 请求处理接口<br>
@@ -139,7 +142,7 @@ abstract public class IMHandler<T> {
 //         }
 
         //json ?
-        return (T)(new Gson().fromJson(new String(bytes), dataCls));
+        return (T)(GsonUtil.gson.fromJson(new String(bytes), dataCls));
     }
 
     public static void init(IMessagesStore ms, ISessionsStore ss, MessagesPublisher p, ThreadPoolExecutorWrapper businessExecutor, Server server) {
@@ -162,18 +165,17 @@ abstract public class IMHandler<T> {
         mLimitCounter = new RateLimiter(5, clientRateLimit);
     }
 
+    boolean isNotLimitTopic(String topic) {
+        if (PullMessageTopic.equals(topic)
+            || GetUserSettingTopic.equals(topic)) {
+            return true;
+        }
+        return false;
+    }
 
     public ErrorCode preAction(String clientID, String fromUser, String topic, Qos1PublishHandler.IMCallback callback, ProtoConstants.RequestSourceType requestSourceType) {
         LOG.info("imHandler fromUser={}, clientId={}, topic={}", fromUser, clientID, topic);
-        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User && !mLimitCounter.isGranted(clientID + fromUser + topic)) {
-            ByteBuf ackPayload = Unpooled.buffer();
-            ackPayload.ensureWritable(1).writeByte(ERROR_CODE_OVER_FREQUENCY.getCode());
-            try {
-                callback.onIMHandled(ERROR_CODE_OVER_FREQUENCY, ackPayload);
-            } catch (Exception e) {
-                e.printStackTrace();
-                Utility.printExecption(LOG, e);
-            }
+        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User && !isNotLimitTopic(topic) && !mLimitCounter.isGranted(clientID + fromUser + topic)) {
             return ErrorCode.ERROR_CODE_OVER_FREQUENCY;
         }
         return ErrorCode.ERROR_CODE_SUCCESS;
@@ -246,21 +248,21 @@ abstract public class IMHandler<T> {
     public void afterAction(String clientID, String fromUser, String topic, Qos1PublishHandler.IMCallback callback) {
 
     }
-    protected long publish(String username, String clientID, WFCMessage.Message message) {
+    protected long publish(String username, String clientID, WFCMessage.Message message, ProtoConstants.RequestSourceType requestSourceType) {
         Set<String> notifyReceivers = new LinkedHashSet<>();
 
         WFCMessage.Message.Builder messageBuilder = message.toBuilder();
-        int pullType = m_messagesStore.getNotifyReceivers(username, messageBuilder, notifyReceivers);
+        int pullType = m_messagesStore.getNotifyReceivers(username, messageBuilder, notifyReceivers, requestSourceType);
         mServer.getImBusinessScheduler().execute(() -> this.publisher.publish2Receivers(messageBuilder.build(), notifyReceivers, clientID, pullType));
         return notifyReceivers.size();
     }
 
-    protected long saveAndPublish(String username, String clientID, WFCMessage.Message message) {
+    protected long saveAndPublish(String username, String clientID, WFCMessage.Message message, ProtoConstants.RequestSourceType requestSourceType) {
         Set<String> notifyReceivers = new LinkedHashSet<>();
 
         message = m_messagesStore.storeMessage(username, clientID, message);
         WFCMessage.Message.Builder messageBuilder = message.toBuilder();
-        int pullType = m_messagesStore.getNotifyReceivers(username, messageBuilder, notifyReceivers);
+        int pullType = m_messagesStore.getNotifyReceivers(username, messageBuilder, notifyReceivers, requestSourceType);
         mServer.getImBusinessScheduler().execute(() -> this.publisher.publish2Receivers(messageBuilder.build(), notifyReceivers, clientID, pullType));
         return notifyReceivers.size();
     }

broker/src/main/java/io/moquette/imhandler/KickoffGroupMember.java

@@ -29,6 +29,10 @@ public class KickoffGroupMember extends GroupHandler<WFCMessage.RemoveGroupMembe
             errorCode = ErrorCode.ERROR_CODE_NOT_EXIST;
         } else {
             boolean isAdmin = requestSourceType == ProtoConstants.RequestSourceType.Request_From_Admin;
+            if (!isAdmin && groupInfo.getType() == ProtoConstants.GroupType.GroupType_Organization) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+
             boolean isAllow = isAdmin;
             if (!isAllow) {
                 if (groupInfo.getOwner() != null) {
@@ -58,6 +62,13 @@ public class KickoffGroupMember extends GroupHandler<WFCMessage.RemoveGroupMembe
                     return ErrorCode.ERROR_CODE_NOT_RIGHT;
                 }
 
+                if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
+                    int forbiddenClientOperation = m_messagesStore.getGroupForbiddenClientOperation();
+                    if((forbiddenClientOperation & ProtoConstants.ForbiddenClientGroupOperationMask.Forbidden_Kickoff_Group_Member) > 0) {
+                        return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                    }
+                }
+
                 //send notify message first, then kickoff the member
                 if (request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {
                     sendGroupNotification(fromUser, groupInfo.getTargetId(), request.getToLineList(), request.getNotifyContent());

broker/src/main/java/io/moquette/imhandler/LoadRemoteMessagesHandler.java

@@ -33,7 +33,7 @@ public class LoadRemoteMessagesHandler extends IMHandler<WFCMessage.LoadRemoteMe
         }
 
         if (request.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Channel) {
-            if (!m_messagesStore.checkUserInChannel(fromUser, request.getConversation().getTarget())) {
+            if (!m_messagesStore.canSendMessageInChannel(fromUser, request.getConversation().getTarget())) {
                 return ErrorCode.ERROR_CODE_NOT_IN_CHANNEL;
             }
         }

broker/src/main/java/io/moquette/imhandler/ModifyGroupInfoHandler.java

@@ -31,6 +31,19 @@ public class ModifyGroupInfoHandler extends GroupHandler<WFCMessage.ModifyGroupI
             return ErrorCode.ERROR_CODE_NOT_RIGHT;
         }
 
+        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
+            int forbiddenClientOperation = m_messagesStore.getGroupForbiddenClientOperation();
+            if(request.getType() == Modify_Group_Mute) {
+                if((forbiddenClientOperation & ProtoConstants.ForbiddenClientGroupOperationMask.Forbidden_Mute_Group) > 0) {
+                    return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                }
+            } else {
+                if((forbiddenClientOperation & ProtoConstants.ForbiddenClientGroupOperationMask.Forbidden_Modify_Group_Info) > 0) {
+                    return ErrorCode.ERROR_CODE_NOT_RIGHT;
+                }
+            }
+        }
+
         ErrorCode errorCode= m_messagesStore.modifyGroupInfo(fromUser, request.getGroupId(), request.getType(), request.getValue(), isAdmin);
         if (errorCode == ERROR_CODE_SUCCESS) {
             if(request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {

broker/src/main/java/io/moquette/imhandler/QuitGroupHandler.java

@@ -31,7 +31,14 @@ public class QuitGroupHandler extends GroupHandler<WFCMessage.QuitGroupRequest>
             return ErrorCode.ERROR_CODE_NOT_RIGHT;
         }
 
-        ErrorCode errorCode = m_messagesStore.quitGroup(fromUser, request.getGroupId());
+        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
+            int forbiddenClientOperation = m_messagesStore.getGroupForbiddenClientOperation();
+            if((forbiddenClientOperation & ProtoConstants.ForbiddenClientGroupOperationMask.Forbidden_Quit_Group) > 0) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+        }
+
+        ErrorCode errorCode = m_messagesStore.quitGroup(fromUser, request.getGroupId(), isAdmin);
         if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
             if (request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {
                 sendGroupNotification(fromUser, request.getGroupId(), request.getToLineList(), request.getNotifyContent());

broker/src/main/java/io/moquette/imhandler/RecallMessageHandler.java

@@ -34,7 +34,7 @@ public class RecallMessageHandler extends IMHandler<WFCMessage.INT64Buf> {
             return ErrorCode.ERROR_CODE_NOT_EXIST;
         }
 
-        publish(fromUser, clientID, message);
+        publish(message.getFromUser(), clientID, message, requestSourceType);
 
         return errorCode;
     }

broker/src/main/java/io/moquette/imhandler/RouteHandler.java

@@ -32,6 +32,16 @@ public class RouteHandler extends IMHandler<WFCMessage.RouteRequest> {
         }
 
         if (session == null || session.getDeleted() > 0) {
+            if(session == null) {
+                LOG.error("Session for <{}, {}> not exist", fromUser, clientID);
+            } else {
+                LOG.error("Session for <{}, {}> deleted", fromUser, clientID);
+            }
+            return ErrorCode.ERROR_CODE_SECRECT_KEY_MISMATCH;
+        }
+
+        if(request.getPlatform() != session.getPlatform() && m_messagesStore.existSignatures()) {
+            LOG.error("Session <{}, {}> platform is {} mismatch the request {}", session.getUsername(), session.getClientID(), session.getPlatform(), request.getPlatform());
             return ErrorCode.ERROR_CODE_SECRECT_KEY_MISMATCH;
         }
 

broker/src/main/java/io/moquette/imhandler/SendMessageHandler.java

@@ -9,20 +9,20 @@
 package io.moquette.imhandler;
 
 import cn.wildfirechat.pojos.MessagePayload;
+import cn.wildfirechat.pojos.OutputClient;
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
 import com.google.gson.Gson;
 import com.hazelcast.util.StringUtil;
 import io.moquette.BrokerConstants;
+import io.moquette.persistence.MemorySessionStore;
 import io.moquette.spi.impl.Qos1PublishHandler;
 import io.netty.buffer.ByteBuf;
 import cn.wildfirechat.common.ErrorCode;
 import io.netty.buffer.Unpooled;
-import win.liyufan.im.HttpUtils;
-import win.liyufan.im.IMTopic;
-import win.liyufan.im.MessageShardingUtil;
-import win.liyufan.im.Utility;
+import win.liyufan.im.*;
 
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 
@@ -32,7 +32,9 @@ import static cn.wildfirechat.common.ErrorCode.ERROR_CODE_SUCCESS;
 public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
     private int mSensitiveType = 0;  //命中敏感词时，0 失败，1 吞掉， 2 敏感词替换成*。
     private String mForwardUrl = null;
+    private String mSensitiveMessageForwardUrl = null;
     private Set<Integer> mForwardMessageTypes = new HashSet<>();
+    private Set<Integer> mForwardExcludeMessageTypes = new HashSet<>();
     private String mMentionForwardUrl = null;
     private int mBlacklistStrategy = 0; //黑名单中时，0失败，1吞掉。
     private boolean mNoForwardAdminMessage = false;
@@ -47,14 +49,11 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
         mForwardUrl = mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Forward_Url);
         if (!StringUtil.isNullOrEmpty(mForwardUrl)) {
             String forwardTypes = mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Forward_Types);
-            if (!StringUtil.isNullOrEmpty(forwardTypes)) {
-                String[] tss = forwardTypes.split(",");
-                for (String ts:tss) {
-                    mForwardMessageTypes.add(Integer.parseInt(ts.trim()));
-                }
-            }
+            parseTypes(mForwardMessageTypes, forwardTypes);
+            String excludeTypes = mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Forward_Exclude_Types);
+            parseTypes(mForwardExcludeMessageTypes, excludeTypes);
         }
-
+        mSensitiveMessageForwardUrl = mServer.getConfig().getProperty(BrokerConstants.MESSAGE_Sensitive_Forward_Url);
         mMentionForwardUrl = mServer.getConfig().getProperty(BrokerConstants.MESSAGE_MentionMsg_Forward_Url);
 
         try {
@@ -97,6 +96,30 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
 
     }
 
+    private void parseTypes(Collection<Integer> collection, String types) {
+        try {
+            if (!StringUtil.isNullOrEmpty(types)) {
+                String[] tss = types.split(",");
+                for (String ts:tss) {
+                    if(ts.contains("-")) {
+                        String[] ss = ts.split("-");
+                        if(ss.length == 2) {
+                            int begin = Integer.parseInt(ss[0]);
+                            int end = Integer.parseInt(ss[1]);
+                            for (int i = begin; i <= end ; i++) {
+                                collection.add(i);
+                            }
+                        }
+                    } else {
+                        collection.add(Integer.parseInt(ts.trim()));
+                    }
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
     @Override
     public ErrorCode action(ByteBuf ackPayload, String clientID, String fromUser, ProtoConstants.RequestSourceType requestSourceType, WFCMessage.Message message, Qos1PublishHandler.IMCallback callback) {
         ErrorCode errorCode = ErrorCode.ERROR_CODE_SUCCESS;
@@ -154,11 +177,20 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
                     }
                 } else if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Channel) {
                     if(!m_messagesStore.getGroupMuteExceptionTypes().contains(message.getContent().getType())) {
-                        if (!m_messagesStore.checkUserInChannel(fromUser, message.getConversation().getTarget())) {
+                        if (!m_messagesStore.canSendMessageInChannel(fromUser, message.getConversation().getTarget())) {
                             return ErrorCode.ERROR_CODE_NOT_IN_CHANNEL;
                         }
                     }
                 }
+            } else if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Group) {
+                if(m_messagesStore.getGroupInfo(message.getConversation().getTarget()) == null) {
+                    return ErrorCode.ERROR_CODE_NOT_EXIST;
+                }
+            } else if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Channel) {
+                WFCMessage.ChannelInfo channelData = m_messagesStore.getChannelInfo(message.getConversation().getTarget());
+                if(channelData == null || channelData.getStatus() == ProtoConstants.ChannelState.Channel_State_Mask_Deleted) {
+                    return ErrorCode.ERROR_CODE_NOT_EXIST;
+                }
             }
 
             long timestamp = System.currentTimeMillis();
@@ -171,12 +203,20 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
             }
             message = message.toBuilder().setFromUser(fromUser).setMessageId(messageId).setServerTimestamp(timestamp).build();
 
-            if (!StringUtil.isNullOrEmpty(mForwardUrl) && (mForwardMessageTypes.isEmpty() || mForwardMessageTypes.contains(message.getContent().getType())) && !(isAdmin && mNoForwardAdminMessage)) {
-                publisher.forwardMessage(message, mForwardUrl);
+            OutputClient outputClient = null;
+            if(m_messagesStore.isForwardMessageWithClientInfo() && requestSourceType == ProtoConstants.RequestSourceType.Request_From_User && !StringUtil.isNullOrEmpty(clientID)) {
+                MemorySessionStore.Session session = m_sessionsStore.getSession(clientID);
+                if(session != null && session.getUsername().equals(fromUser)) {
+                    outputClient = new OutputClient(session.getPlatform(), clientID);
+                }
+            }
+
+            if (!StringUtil.isNullOrEmpty(mForwardUrl) && (mForwardMessageTypes.isEmpty() || mForwardMessageTypes.contains(message.getContent().getType())) && !(isAdmin && mNoForwardAdminMessage) && !mForwardExcludeMessageTypes.contains(message.getContent().getType())) {
+                publisher.forwardMessage(message, mForwardUrl, outputClient);
             }
 
             if(!StringUtil.isNullOrEmpty(mMentionForwardUrl) && message.hasContent() && message.getContent().getMentionedType() != 0 && !(isAdmin && mNoForwardAdminMessage)) {
-                publisher.forwardMessage(message, mMentionForwardUrl);
+                publisher.forwardMessage(message, mMentionForwardUrl, outputClient);
             }
 
             if (!isAdmin) {
@@ -184,6 +224,9 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
                     Set<String> matched = m_messagesStore.handleSensitiveWord(message.getContent().getSearchableContent());
                     if (matched != null && !matched.isEmpty()) {
                         m_messagesStore.storeSensitiveMessage(message);
+                        if (!StringUtil.isNullOrEmpty(mSensitiveMessageForwardUrl)) {
+                            publisher.forwardMessage(message, mSensitiveMessageForwardUrl, outputClient);
+                        }
                         if (mSensitiveType == 0) {
                             errorCode = ErrorCode.ERROR_CODE_SENSITIVE_MATCHED;
                         } else if (mSensitiveType == 1) {
@@ -203,15 +246,15 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
                             @Override
                             public void onSuccess(String content) {
                                 if(StringUtil.isNullOrEmpty(content)) {
-                                    saveAndPublish(fromUser, clientID, finalMsg);
+                                    saveAndPublish(fromUser, clientID, finalMsg, requestSourceType);
                                 } else {
-                                    MessagePayload payload = new Gson().fromJson(content, MessagePayload.class);
+                                    MessagePayload payload = GsonUtil.gson.fromJson(content, MessagePayload.class);
                                     if (payload != null && payload.getType() > 0) {
                                         WFCMessage.Message newMsg = finalMsg.toBuilder().setContent(payload.toProtoMessageContent()).build();
-                                        saveAndPublish(fromUser, clientID, newMsg);
+                                        saveAndPublish(fromUser, clientID, newMsg, requestSourceType);
                                     } else {
                                         LOG.error("Response content {} from censor is invalid payload, ignore response and send original message", content);
-                                        saveAndPublish(fromUser, clientID, finalMsg);
+                                        saveAndPublish(fromUser, clientID, finalMsg, requestSourceType);
                                     }
                                 }
                                 if(mWaitRemoteSensitiveServerResponse) {
@@ -236,7 +279,7 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
                                     }
                                 } else {
                                     LOG.warn("Failed to censor message with status {}, errorMessage {}. Send the original message", statusCode, errorMessage);
-                                    saveAndPublish(fromUser, clientID, finalMsg);
+                                    saveAndPublish(fromUser, clientID, finalMsg, requestSourceType);
 
                                     if(mWaitRemoteSensitiveServerResponse) {
                                         errorCode = ERROR_CODE_SUCCESS;
@@ -268,7 +311,7 @@ public class SendMessageHandler extends IMHandler<WFCMessage.Message> {
 
             if (errorCode == ErrorCode.ERROR_CODE_SUCCESS) {
                 if(!ignoreMsg) {
-                    saveAndPublish(fromUser, clientID, message);
+                    saveAndPublish(fromUser, clientID, message, requestSourceType);
                 }
                 ackPayload = ackPayload.capacity(20);
                 ackPayload.writeLong(messageId);

broker/src/main/java/io/moquette/imhandler/SetGroupManagerHandler.java

@@ -30,6 +30,13 @@ public class SetGroupManagerHandler extends GroupHandler<WFCMessage.SetGroupMana
             return ErrorCode.ERROR_CODE_NOT_RIGHT;
         }
 
+        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
+            int forbiddenClientOperation = m_messagesStore.getGroupForbiddenClientOperation();
+            if((forbiddenClientOperation & ProtoConstants.ForbiddenClientGroupOperationMask.Forbidden_Set_Group_Manage) > 0) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+        }
+
         ErrorCode errorCode = m_messagesStore.setGroupManager(fromUser, request.getGroupId(), request.getType(), request.getUserIdList(), isAdmin);
         if (errorCode == ERROR_CODE_SUCCESS) {
             if (request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {

broker/src/main/java/io/moquette/imhandler/TransferGroupHandler.java

@@ -30,6 +30,13 @@ public class TransferGroupHandler extends GroupHandler<WFCMessage.TransferGroupR
             return ErrorCode.ERROR_CODE_NOT_RIGHT;
         }
 
+        if(requestSourceType == ProtoConstants.RequestSourceType.Request_From_User) {
+            int forbiddenClientOperation = m_messagesStore.getGroupForbiddenClientOperation();
+            if((forbiddenClientOperation & ProtoConstants.ForbiddenClientGroupOperationMask.Forbidden_Transfer_Group) > 0) {
+                return ErrorCode.ERROR_CODE_NOT_RIGHT;
+            }
+        }
+
         ErrorCode errorCode = m_messagesStore.transferGroup(fromUser, request.getGroupId(), request.getNewOwner(), isAdmin);
         if (errorCode == ERROR_CODE_SUCCESS) {
             if (request.hasNotifyContent() && request.getNotifyContent().getType() > 0) {

broker/src/main/java/io/moquette/imhandler/UploadDeviceTokenHandler.java

@@ -25,9 +25,11 @@ public class UploadDeviceTokenHandler extends IMHandler<WFCMessage.UploadDeviceT
             session.setPlatform(request.getPlatform());
             session.setAppName(request.getAppName());
             if (request.getPlatform() == ProtoConstants.Platform.Platform_iOS && request.getPushType() == 2) {
+                LOG.info("Set device token, userId {}", fromUser);
                 session.setVoipDeviceToken(request.getDeviceToken());
                 m_sessionsStore.updateSessionToken(session, true);
             } else {
+                LOG.info("Set device token, userId {}, platform {}, pushType {}", fromUser, session.getPlatform(), request.getPushType());
                 session.setDeviceToken(request.getDeviceToken());
                 session.setPushType(request.getPushType());
                 m_sessionsStore.updateSessionToken(session, false);

broker/src/main/java/io/moquette/interception/messages/InterceptConnectMessage.java

@@ -72,7 +72,7 @@ public class InterceptConnectMessage extends InterceptAbstractMessage {
     }
 
     public byte[] getPassword() {
-        return msg.payload().password();
+        return msg.payload().passwordInBytes();
     }
 
     public String getWillTopic() {

broker/src/main/java/io/moquette/persistence/DatabaseStore.java

@@ -203,7 +203,7 @@ public class DatabaseStore {
             }
 
 
-            sql += " and _type <> 2"; //can search normal user(0) and robot(1) and admin(100), can not search things
+            sql += " and `_type` <> 2 and `_deleted` = 0"; //can search normal user(0) and robot(1) and admin(100), can not search things
 
             if (searchType == SearchUserType_Name_Mobile || searchType == SearchUserType_Name || searchType == SearchUserType_Mobile) {
                 sql += " limit 1";
@@ -553,7 +553,7 @@ public class DatabaseStore {
                 statement.setInt(index++, message.getContent().getType());
                 String to = message.getToUser();
                 if (StringUtil.isNullOrEmpty(message.getToUser())) {
-                    if (message.getToList()!= null && message.getToList().size() == 1) {
+                    if (message.getToList().size() > 0) {
                         to = message.getToList().get(0);
                     }
                 }
@@ -815,7 +815,7 @@ public class DatabaseStore {
         long beforeUid = before[0];
         String sql = "select `_mid`, `_from`, `_type`, `_target`, `_line`, `_data`, `_dt`, `_to` from " + table +" where";
         if (conversation.getType() == ProtoConstants.ConversationType.ConversationType_Private) {
-            sql += " _type = ? and _line = ? and _mid < ? and ((_target = ?  and _from = ?) or (_target = ?  and _from = ?))";
+            sql += " _type = ? and _line = ? and _mid < ? and ((_target = ?  and _from = ?) or (_target = ?  and _from = ?)) and (_to = '' or _to = ?)";
         } else if (conversation.getType() == ProtoConstants.ConversationType.ConversationType_Channel && !user.equals(channelOwner)) {
             sql += " _type = ? and _line = ? and _mid < ? and _target = ? and ((_from = ? and (_to = '' or _to = ?)) or (_from = ?))";
         } else {
@@ -853,6 +853,7 @@ public class DatabaseStore {
                 statement.setString(index++, user);
                 statement.setString(index++, user);
                 statement.setString(index++, conversation.getTarget());
+                statement.setString(index++, user);
             } else if (conversation.getType() == ProtoConstants.ConversationType.ConversationType_Channel && !user.equals(channelOwner)) {
                 statement.setString(index++, channelOwner);
                 statement.setString(index++, user);
@@ -914,20 +915,24 @@ public class DatabaseStore {
         return false;
     }
 
-    void persistUserMessage(final String userId, final long messageId, final long messageSeq, final int messageContentType) {
+    void persistUserMessage(final String userId, final  String sender, final long messageId, final long messageSeq, int type, String target, int line, boolean directing, final int messageContentType) {
         mScheduler.execute(()->{
             Connection connection = null;
             PreparedStatement statement = null;
             try {
                 connection = DBUtil.getConnection();
 
-                String sql = "insert into " + getUserMessageTable(userId) + " (`_mid`, `_uid`, `_seq`, `_cont_type`) values(?, ?, ?, ?)";
+                String sql = "insert into " + getUserMessageTable(userId) + " (`_mid`, `_uid`, `_seq`, `_type`, `_target`, `_line`, `_directing`, `_cont_type`) values(?, ?, ?, ?, ?, ?, ?, ?)";
 
                 statement = connection.prepareStatement(sql);
                 int index = 1;
                 statement.setLong(index++, messageId);
                 statement.setString(index++, userId);
                 statement.setLong(index++, messageSeq);
+                statement.setInt(index++, type);
+                statement.setString(index++, getPrivateChatUserMessageTarget(type, target, sender));
+                statement.setInt(index++, line);
+                statement.setInt(index++, directing ? 1 :0);
                 statement.setInt(index++, messageContentType);
                 int count = statement.executeUpdate();
                 LOG.info("Update rows {}", count);
@@ -941,6 +946,14 @@ public class DatabaseStore {
         });
     }
 
+    String getPrivateChatUserMessageTarget(int conversationType, String target, String userId) {
+        if(conversationType == ProtoConstants.ConversationType.ConversationType_Private) {
+            return target.compareTo(userId) > 0 ? (userId + "|" + target) : (target + "|" + userId);
+        } else {
+            return target;
+        }
+    }
+
     void clearUserMessage(final String userId) {
         mScheduler.execute(()->{
             String tableName = getUserMessageTable(userId);
@@ -990,7 +1003,7 @@ public class DatabaseStore {
             }
             sb.append(")");
 
-            sb.append(" and _scope = 6 and _key = ?");
+            sb.append(" and _scope in (5,6,26) and _key = ?");
 
             statement = connection.prepareStatement(sb.toString());
             int index = 1;
@@ -1138,23 +1151,21 @@ public class DatabaseStore {
         try {
             connection = DBUtil.getConnection();
 
-            StringBuilder sb = new StringBuilder("delete from t_user_setting where _scope in (1,3,5,7) and _uid in (");
+            StringBuilder sb = new StringBuilder("delete from t_user_setting where _scope in (1,3,5,6,7,19) and _uid in (");
             for (int i = 0; i < users.size(); i++) {
                 sb.append("?");
                 if (i != users.size() - 1) {
                     sb.append(",");
                 }
             }
-            sb.append(") and _key like '1-_-");
-            sb.append(groupId);
-            sb.append("'");
-
+            sb.append(") and _key like ?");
 
             statement = connection.prepareStatement(sb.toString());
             int index = 1;
             for (String userId:users) {
                 statement.setString(index++, userId);
             }
+            statement.setString(index++, "1-_-" + groupId);
 
             int count = statement.executeUpdate();
             LOG.info("Update rows {}", count);
@@ -1491,12 +1502,6 @@ public class DatabaseStore {
                 if (!strEqual(session.getAppName(), request.getApp())) {
                     sql += " `_package_name` = ?,";
                 }
-                if (session.getPlatform() != request.getPlatform()) {
-                    sql += " `_platform` = ?,";
-                }
-                if (session.getPushType() != request.getPushType()) {
-                    sql += " `_push_type` = ?,";
-                }
                 if (!strEqual(session.getDeviceName(), request.getDeviceName())) {
                     sql += " `_device_name` = ?,";
                 }
@@ -1524,12 +1529,6 @@ public class DatabaseStore {
                 if (!strEqual(session.getAppName(), request.getApp())) {
                     statement.setString(index++, request.getApp());
                 }
-                if (session.getPlatform() != request.getPlatform()) {
-                    statement.setInt(index++, request.getPlatform());
-                }
-                if (session.getPushType() != request.getPushType()) {
-                    statement.setInt(index++, request.getPushType() >= 32 ? 0 : request.getPushType());
-                }
                 if (!strEqual(session.getDeviceName(), request.getDeviceName())) {
                     statement.setString(index++, request.getDeviceName());
                 }
@@ -1710,6 +1709,35 @@ public class DatabaseStore {
         return null;
     }
 
+    Set<String> getCommonGroupIds(String userId1, String userId2) {
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select t1._gid from t_group_member t1, t_group_member t2 where t1._mid = ? and t2._mid = ? and t1._type <> 4 and t2._type <> 4 and t1._gid = t2._gid";
+            statement = connection.prepareStatement(sql);
+
+            statement.setString(1, userId1);
+            statement.setString(2, userId2);
+
+            rs = statement.executeQuery();
+            Set<String> out = new HashSet<>();
+            while (rs.next()) {
+                String uid = rs.getString(1);
+                out.add(uid);
+            }
+            return out;
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+        return null;
+    }
+
     void updateGroupMemberDt(final String groupId, final long dt) {
         Connection connection = null;
         PreparedStatement statement = null;
@@ -2383,59 +2411,55 @@ public class DatabaseStore {
     }
 
     void deleteUserStatus(String userId) {
-        mScheduler.execute(()->{
-            Connection connection = null;
-            PreparedStatement statement = null;
-            try {
-                connection = DBUtil.getConnection();
+        Connection connection = null;
+        PreparedStatement statement = null;
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "delete from t_user_status where _uid = ?";
+            statement = connection.prepareStatement(sql);
+            statement.setString(1, userId);
+            int count = statement.executeUpdate();
+            LOG.info("Update rows {}", count);
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement);
+        }
+    }
+
+    void updateUserStatus(String userId, int status) {
+        Connection connection = null;
+        PreparedStatement statement = null;
+        try {
+            connection = DBUtil.getConnection();
+            if (status == 0) {
                 String sql = "delete from t_user_status where _uid = ?";
                 statement = connection.prepareStatement(sql);
                 statement.setString(1, userId);
                 int count = statement.executeUpdate();
                 LOG.info("Update rows {}", count);
-            } catch (SQLException e) {
-                // TODO Auto-generated catch block
-                e.printStackTrace();
-                Utility.printExecption(LOG, e, RDBS_Exception);
-            } finally {
-                DBUtil.closeDB(connection, statement);
+            } else {
+                String sql = "insert into t_user_status (`_uid`, `_status`, `_dt`) values(?,?,?) ON DUPLICATE KEY UPDATE `_status` = ?";
+
+                statement = connection.prepareStatement(sql);
+                int index = 1;
+                statement.setString(index++, userId);
+                statement.setInt(index++, status);
+                statement.setLong(index++,  System.currentTimeMillis());
+                statement.setInt(index++, status);
+
+                int count = statement.executeUpdate();
+                LOG.info("Update rows {}", count);
             }
-        });
-    }
-
-    void updateUserStatus(String userId, int status) {
-        mScheduler.execute(()->{
-            Connection connection = null;
-            PreparedStatement statement = null;
-            try {
-                connection = DBUtil.getConnection();
-                if (status == 0) {
-                    String sql = "delete from t_user_status where _uid = ?";
-                    statement = connection.prepareStatement(sql);
-                    statement.setString(1, userId);
-                    int count = statement.executeUpdate();
-                    LOG.info("Update rows {}", count);
-                } else {
-                    String sql = "insert into t_user_status (`_uid`, `_status`, `_dt`) values(?,?,?) ON DUPLICATE KEY UPDATE `_status` = ?";
-
-                    statement = connection.prepareStatement(sql);
-                    int index = 1;
-                    statement.setString(index++, userId);
-                    statement.setInt(index++, status);
-                    statement.setLong(index++,  System.currentTimeMillis());
-                    statement.setInt(index++, status);
-
-                    int count = statement.executeUpdate();
-                    LOG.info("Update rows {}", count);
-                }
-            } catch (SQLException e) {
-                // TODO Auto-generated catch block
-                e.printStackTrace();
-                Utility.printExecption(LOG, e, RDBS_Exception);
-            } finally {
-                DBUtil.closeDB(connection, statement);
-            }
-        });
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement);
+        }
     }
 
     int getGeneratedId() {
@@ -2970,7 +2994,8 @@ public class DatabaseStore {
                     ", `_secret`" +
                     ", `_callback`" +
                     ", `_automatic`" +
-                    ", `_dt`) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" +
+                    ", `_menu`" +
+                    ", `_dt`) values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" +
                     " ON DUPLICATE KEY UPDATE `_name`=?" +
                     ", `_portrait`=?" +
                     ", `_owner`=?" +
@@ -2980,12 +3005,20 @@ public class DatabaseStore {
                     ", `_secret`=?" +
                     ", `_callback`=?" +
                     ", `_automatic`=?" +
+                    ", `_menu`=?" +
                     ", `_dt`=?";
 
                 statement = connection.prepareStatement(sql);
 
-                int index = 1;
+                WFCMessage.ChannelMenuList.Builder builder = WFCMessage.ChannelMenuList.newBuilder();
+                if (!channelInfo.getMenuList().isEmpty()) {
+                    for (WFCMessage.ChannelMenu menuBtn:channelInfo.getMenuList()) {
+                        builder.addMenu(menuBtn);
+                    }
+                }
+                byte[] menuBytes = builder.build().toByteArray();
 
+                int index = 1;
                 statement.setString(index++, channelInfo.getTargetId());
                 statement.setString(index++, channelInfo.getName());
                 statement.setString(index++, channelInfo.getPortrait());
@@ -2996,6 +3029,7 @@ public class DatabaseStore {
                 statement.setString(index++, channelInfo.getSecret());
                 statement.setString(index++, channelInfo.getCallback());
                 statement.setInt(index++, channelInfo.getAutomatic());
+                statement.setBytes(index++, menuBytes);
                 statement.setLong(index++, channelInfo.getUpdateDt() == 0 ? System.currentTimeMillis() : channelInfo.getUpdateDt());
 
                 statement.setString(index++, channelInfo.getName());
@@ -3007,6 +3041,7 @@ public class DatabaseStore {
                 statement.setString(index++, channelInfo.getSecret());
                 statement.setString(index++, channelInfo.getCallback());
                 statement.setInt(index++, channelInfo.getAutomatic());
+                statement.setBytes(index++, menuBytes);
                 statement.setLong(index++, channelInfo.getUpdateDt() == 0 ? System.currentTimeMillis() : channelInfo.getUpdateDt());
 
                 int count = statement.executeUpdate();
@@ -3059,6 +3094,7 @@ public class DatabaseStore {
                 ", `_secret`" +
                 ", `_callback`" +
                 ", `_automatic`" +
+                ", `_menu`" +
                 ", `_dt` from t_channel  where `_cid` = ?";
 
             statement = connection.prepareStatement(sql);
@@ -3109,6 +3145,21 @@ public class DatabaseStore {
                 intValue = rs.getInt(index++);
                 builder.setAutomatic(intValue);
 
+                try {
+                    byte[] bytes = null;
+                    Blob blob = rs.getBlob(index++);
+                    if (blob != null) {
+                        bytes = toByteArray(blob.getBinaryStream());
+                    }
+
+                    WFCMessage.ChannelMenuList menuButtonList = WFCMessage.ChannelMenuList.parseFrom(bytes);
+                    if (menuButtonList.getMenuCount() > 0) {
+                        builder.addAllMenu(menuButtonList.getMenuList());
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+
                 long longValue = rs.getLong(index++);
                 builder.setUpdateDt(longValue);
 
@@ -3287,47 +3338,96 @@ public class DatabaseStore {
     }
 
     void updateChannelListener(final String channelId, final String listener, final boolean listen) {
-        LOG.info("Database remove channel {}", channelId);
-        mScheduler.execute(()->{
-            Connection connection = null;
-            PreparedStatement statement = null;
-            try {
-                connection = DBUtil.getConnection();
-                String sql;
-                if (listen) {
-                    sql = "insert into t_channel_listener (`_cid`" +
-                        ", `_mid`" +
-                        ", `_dt`) values(?, ?, ?)" +
-                        " ON DUPLICATE KEY UPDATE " +
-                        "`_dt` = ?";
-                    statement = connection.prepareStatement(sql);
-                    int index = 1;
-                    statement.setString(index++, channelId);
-                    statement.setString(index++, listener);
-                    statement.setLong(index++, System.currentTimeMillis());
-                    statement.setLong(index++, System.currentTimeMillis());
+        LOG.info("updateChannelListener channel {}, listener {}, listen {}", channelId, listener, listen);
+        Connection connection = null;
+        PreparedStatement statement = null;
+        try {
+            connection = DBUtil.getConnection();
+            String sql;
+            if (listen) {
+                sql = "insert into t_channel_listener (`_cid`" +
+                    ", `_mid`" +
+                    ", `_dt`) values(?, ?, ?)" +
+                    " ON DUPLICATE KEY UPDATE " +
+                    "`_dt` = ?";
+                statement = connection.prepareStatement(sql);
+                int index = 1;
+                statement.setString(index++, channelId);
+                statement.setString(index++, listener);
+                statement.setLong(index++, System.currentTimeMillis());
+                statement.setLong(index++, System.currentTimeMillis());
 
-                    int count = statement.executeUpdate();
-                    LOG.info("Update rows {}", count);
-                } else {
-                    sql = "delete from t_channel_listener where `_cid`=? and `_mid`=?";
+                int count = statement.executeUpdate();
+                LOG.info("Update rows {}", count);
+            } else {
+                sql = "delete from t_channel_listener where `_cid`=? and `_mid`=?";
 
-                    statement = connection.prepareStatement(sql);
-                    int index = 1;
-                    statement.setString(index++, channelId);
-                    statement.setString(index++, listener);
+                statement = connection.prepareStatement(sql);
+                int index = 1;
+                statement.setString(index++, channelId);
+                statement.setString(index++, listener);
 
-                    int count = statement.executeUpdate();
-                    LOG.info("Update rows {}", count);
-                }
-            } catch (SQLException e) {
-                // TODO Auto-generated catch block
-                e.printStackTrace();
-                Utility.printExecption(LOG, e, RDBS_Exception);
-            } finally {
-                DBUtil.closeDB(connection, statement);
+                int count = statement.executeUpdate();
+                LOG.info("Update rows {}", count);
             }
-        });
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement);
+        }
+    }
+
+    List<String> getUserChannels(String userId) {
+        List<String> out = new ArrayList<>();
+
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet rs = null;
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "select _cid from t_channel_listener where _mid = ?";
+            statement = connection.prepareStatement(sql);
+
+            int index = 1;
+            statement.setString(index++, userId);
+
+            rs = statement.executeQuery();
+            while (rs.next()) {
+                String value = rs.getString(1);
+                if (!StringUtil.isNullOrEmpty(value)) {
+                    out.add(value);
+                }
+            }
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement, rs);
+        }
+        return out;
+    }
+
+    void clearChannelListener(final String channelId) {
+        LOG.info("Database remove channel {}", channelId);
+        Connection connection = null;
+        PreparedStatement statement = null;
+        try {
+            connection = DBUtil.getConnection();
+            String sql = "delete from t_channel_listener where _cid=?";
+            statement = connection.prepareStatement(sql);
+            statement.setString(1, channelId);
+            int count = statement.executeUpdate();
+            LOG.info("Update rows {}", count);
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+            Utility.printExecption(LOG, e, RDBS_Exception);
+        } finally {
+            DBUtil.closeDB(connection, statement);
+        }
     }
 
     public Set<String> getSensitiveWord() {

broker/src/main/java/io/moquette/persistence/MemorySessionStore.java

@@ -39,6 +39,7 @@ public class MemorySessionStore implements ISessionsStore {
     private static final Logger LOG = LoggerFactory.getLogger(MemorySessionStore.class);
 
     private boolean supportMultiEndpoint = false;
+    private boolean supportMultiPCEndpoint = false;
     private boolean clientSupportKickoff = false;
 
     public static class Session implements Comparable<Session>{
@@ -287,6 +288,11 @@ public class MemorySessionStore implements ISessionsStore {
             Utility.printExecption(LOG, e);
         }
 
+        try {
+            supportMultiPCEndpoint = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.SERVER_MULTI_PC_ENDPOINT, "false"));
+        } catch (Exception e) {
+        }
+
         try {
             clientSupportKickoff = Boolean.parseBoolean(server.getConfig().getProperty(BrokerConstants.SERVER_CLIENT_SUPPORT_KICKOFF_EVENT, "false"));
         } catch (Exception e) {
@@ -385,7 +391,12 @@ public class MemorySessionStore implements ISessionsStore {
         }
         databaseStore.clearMultiUser(username, clientID);
 
-        if (!supportMultiEndpoint && platform > 0) {
+        if (!supportMultiEndpoint
+            && platform > 0
+            && !(platform == ProtoConstants.Platform.Platform_Windows && supportMultiPCEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_LINUX && supportMultiPCEndpoint)
+            && !(platform == ProtoConstants.Platform.Platform_OSX && supportMultiPCEndpoint)
+        ) {
             databaseStore.clearMultiEndpoint(username, clientID, platform);
             if (userSessions.get(username) != null) {
                 Iterator<String> it = userSessions.get(username).iterator();
@@ -404,7 +415,7 @@ public class MemorySessionStore implements ISessionsStore {
                                 remove = true;
                             }
                         } else if(platform == ProtoConstants.Platform.Platform_OSX || platform == ProtoConstants.Platform.Platform_Windows || platform == ProtoConstants.Platform.Platform_LINUX) {
-                            if (s.getPlatform() == ProtoConstants.Platform.Platform_OSX || s.getPlatform() == ProtoConstants.Platform.Platform_Windows || platform == ProtoConstants.Platform.Platform_LINUX) {
+                            if (s.getPlatform() == ProtoConstants.Platform.Platform_OSX || s.getPlatform() == ProtoConstants.Platform.Platform_Windows || s.getPlatform() == ProtoConstants.Platform.Platform_LINUX) {
                                 remove = true;
                             }
                         } else {
@@ -723,6 +734,11 @@ public class MemorySessionStore implements ISessionsStore {
     public ErrorCode kickoffPCClient(String operator, String pcClientId) {
         Session session = sessions.get(pcClientId);
         if (session != null) {
+            if(!operator.equals(session.getUsername())) {
+                LOG.error("kickoffPCClient failure, user {} don't have client {}", operator, pcClientId);
+                mServer.getProcessor().getMessagesStore().forceCleanOnlineStatus(operator, pcClientId);
+                return ErrorCode.ERROR_CODE_SUCCESS;
+            }
             if (session.getPlatform() == ProtoConstants.Platform.Platform_LINUX
                 || session.getPlatform() == ProtoConstants.Platform.Platform_WEB
                 || session.getPlatform() == ProtoConstants.Platform.Platform_Windows
@@ -731,8 +747,12 @@ public class MemorySessionStore implements ISessionsStore {
                 sessions.remove(pcClientId);
                 mServer.getProcessor().kickoffSession(session);
             } else {
+                LOG.error("session {} is not pc client:{}", pcClientId, session.getPlatform());
                 return ErrorCode.ERROR_CODE_NOT_RIGHT;
             }
+        } else {
+            LOG.error("Can't find the session for client <{}>", pcClientId);
+            mServer.getProcessor().getMessagesStore().forceCleanOnlineStatus(operator, pcClientId);
         }
         return ErrorCode.ERROR_CODE_SUCCESS;
     }
@@ -742,10 +762,12 @@ public class MemorySessionStore implements ISessionsStore {
     public void disableSession(String userId, String clientId) {
         Session session = sessions.get(clientId);
         if (session != null && session.getDeleted() == 0 && (userId == null || session.getUsername().equals(userId))) {
-            databaseStore.updateSessionDeleted(session.getUsername(), clientId, 1);
-            ConcurrentSkipListSet<String> sessionSet = getUserSessionSet(session.username);
-            sessionSet.remove(clientId);
-            sessions.remove(clientId);
+            mServer.getProcessor().processOffline(session, true, () -> {
+                databaseStore.updateSessionDeleted(session.getUsername(), clientId, 1);
+                ConcurrentSkipListSet<String> sessionSet = getUserSessionSet(session.username);
+                sessionSet.remove(clientId);
+                sessions.remove(clientId);
+            });
         }
     }
 
@@ -763,23 +785,25 @@ public class MemorySessionStore implements ISessionsStore {
             return;
         }
 
-        ConcurrentSkipListSet<String> sessionSet = getUserSessionSet(session.username);
-        sessionSet.remove(clientID);
+        mServer.getProcessor().processOffline(session, true, () -> {
+            ConcurrentSkipListSet<String> sessionSet = getUserSessionSet(session.username);
+            sessionSet.remove(clientID);
 
-        // remove also the messages stored of type QoS1/2
-        LOG.info("Removing stored messages with QoS 1 and 2. ClientId={}", clientID);
+            // remove also the messages stored of type QoS1/2
+            LOG.info("Removing stored messages with QoS 1 and 2. ClientId={}", clientID);
 
-        session.secondPhaseStore.clear();
-        session.outboundFlightMessages.clear();
-        session.inboundFlightMessages.clear();
+            session.secondPhaseStore.clear();
+            session.outboundFlightMessages.clear();
+            session.inboundFlightMessages.clear();
 
-        LOG.info("Wiping existing subscriptions. ClientId={}", clientID);
+            LOG.info("Wiping existing subscriptions. ClientId={}", clientID);
 
-        //remove also the enqueued messages
-        dropQueue(clientID);
+            //remove also the enqueued messages
+            dropQueue(clientID);
 
-        // TODO this missing last step breaks the junit test
-        sessions.remove(clientID);
+            // TODO this missing last step breaks the junit test
+            sessions.remove(clientID);
+        });
     }
     @Override
     public boolean isMultiEndpointSupported() {

broker/src/main/java/io/moquette/server/Server.java

@@ -369,9 +369,6 @@ public class Server {
     private String getServerIp(IConfig config) {
         String serverIp = config.getProperty(BrokerConstants.SERVER_IP_PROPERTY_NAME);
         if (serverIp == null || serverIp.equals("0.0.0.0")) {
-            String warning = "警告：无效配置，server.ip不能为空，需要配置服务的公网IP地址或者域名才能在公网使用！！！\nIM服务将使用本地地址，只能在局域网内使用！";
-            System.out.println(warning);
-            LOG.error(warning);
             serverIp = Utility.getLocalAddress().getHostAddress();
         }
         return serverIp;
@@ -381,7 +378,7 @@ public class Server {
         LOG.info("Configuring embedded Hazelcast instance");
 
         serverIp = getServerIp(config);
-        String hzConfigPath = "config/hazelcast.xml";
+        String hzConfigPath = System.getProperty("hazelcast.configuration", "config/hazelcast.xml");
         if (hzConfigPath != null) {
             boolean isHzConfigOnClasspath = this.getClass().getClassLoader().getResource(hzConfigPath) != null;
             Config hzconfig = isHzConfigOnClasspath

broker/src/main/java/io/moquette/server/netty/NettyAcceptor.java

@@ -160,7 +160,7 @@ public class NettyAcceptor implements ServerAcceptor {
                                              IConfig props) throws IOException {
         LOG.info("Configuring TCP MQTT transport");
         final MoquetteIdleTimeoutHandler timeoutHandler = new MoquetteIdleTimeoutHandler();
-        String host = props.getProperty(BrokerConstants.HOST_PROPERTY_NAME);
+        String host = props.getProperty(BrokerConstants.HOST_PROPERTY_NAME, "0.0.0.0");
         String tcpPortProp = props.getProperty(PORT_PROPERTY_NAME, DISABLED_PORT_BIND);
         if (DISABLED_PORT_BIND.equals(tcpPortProp)) {
             LOG.info("Property {} has been set to {}. TCP MQTT will be disabled", BrokerConstants.PORT_PROPERTY_NAME,

broker/src/main/java/io/moquette/spi/IMessagesStore.java

@@ -18,6 +18,7 @@ package io.moquette.spi;
 
 import cn.wildfirechat.pojos.InputOutputUserInfo;
 import cn.wildfirechat.pojos.SystemSettingPojo;
+import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
 import com.xiaoleilu.loServer.model.FriendData;
 import cn.wildfirechat.pojos.InputOutputUserBlockStatus;
@@ -101,23 +102,24 @@ public interface IMessagesStore {
     DatabaseStore getDatabaseStore();
     WFCMessage.Message storeMessage(String fromUser, String fromClientId, WFCMessage.Message message);
     void storeSensitiveMessage(WFCMessage.Message message);
-	int getNotifyReceivers(String fromUser, WFCMessage.Message.Builder message, Set<String> notifyReceivers);
+	int getNotifyReceivers(String fromUser, WFCMessage.Message.Builder message, Set<String> notifyReceivers, ProtoConstants.RequestSourceType requestSourceType);
     Set<String> getAllEnds();
     WFCMessage.PullMessageResult fetchMessage(String user, String exceptClientId, long fromMessageId, int pullType);
     WFCMessage.PullMessageResult loadRemoteMessages(String user, WFCMessage.Conversation conversation, long beforeUid, int count, Collection<Integer> contentTypes);
-    long insertUserMessages(String sender, int conversationType, String target, int line, int messageContentType, String userId, long messageId);
+    long insertUserMessages(String sender, int conversationType, String target, int line, int messageContentType, String userId, long messageId, boolean directing);
     WFCMessage.GroupInfo createGroup(String operator, WFCMessage.GroupInfo groupInfo, List<WFCMessage.GroupMember> memberList, String memberExtra, boolean isAdmin);
     ErrorCode addGroupMembers(String operator, boolean isAdmin, String groupId, List<WFCMessage.GroupMember> memberList, String extra);
     ErrorCode kickoffGroupMembers(String operator, boolean isAdmin, String groupId, List<String> memberList);
-    ErrorCode quitGroup(String operator, String groupId);
+    ErrorCode quitGroup(String operator, String groupId, boolean admin);
     void clearUserGroups(String userId);
     ErrorCode dismissGroup(String operator, String groupId, boolean isAdmin);
     ErrorCode modifyGroupInfo(String operator, String groupId, int modifyType, String value, boolean isAdmin);
     ErrorCode modifyGroupMemberAlias(String operator, String groupId, String alias, String memberId, boolean isAdmin);
     ErrorCode modifyGroupMemberExtra(String operator, String groupId, String extra, String memberId, boolean isAdmin);
-    List<WFCMessage.GroupInfo> getGroupInfos(List<WFCMessage.UserRequest> requests);
+    List<WFCMessage.GroupInfo> getGroupInfos(List<WFCMessage.UserRequest> requests, String fromUser, boolean isAdmin);
     WFCMessage.GroupInfo getGroupInfo(String groupId);
     Set<String> getUserGroupIds(String userId);
+    Set<String> getCommonGroupIds(String userId1, String userId2);
     ErrorCode getGroupMembers(String fromUser, String groupId, long maxDt, List<WFCMessage.GroupMember> members);
     WFCMessage.GroupMember getGroupMember(String groupId, String memberId);
     ErrorCode transferGroup(String operator, String groupId, String newOwner, boolean isAdmin);
@@ -139,6 +141,8 @@ public interface IMessagesStore {
 
     ErrorCode modifyUserInfo(String userId, WFCMessage.ModifyMyInfoRequest request) throws Exception;
 
+    void forceCleanOnlineStatus(String userId, String clientId);
+
     void updateUserOnlineSetting(MemorySessionStore.Session session, boolean online);
 
     ErrorCode modifyUserStatus(String userId, int status);
@@ -147,7 +151,7 @@ public interface IMessagesStore {
 
     ErrorCode updateUserInfo(InputOutputUserInfo userInfo, int flag);
     void addUserInfo(WFCMessage.User user, String password) throws Exception;
-    void destoryUser(String userId);
+    void destroyUser(String userId);
     void updateUserInfo(WFCMessage.User user) throws Exception;
     WFCMessage.User getUserInfo(String userId);
     WFCMessage.User getUserInfoByName(String name);
@@ -176,7 +180,6 @@ public interface IMessagesStore {
 
     ErrorCode saveAddFriendRequest(String userId, WFCMessage.AddFriendRequest request, long[] head, boolean isAdmin);
     ErrorCode handleFriendRequest(String userId, WFCMessage.HandleFriendRequest request, WFCMessage.Message.Builder msgBuilder, long[] heads, boolean isAdmin);
-    boolean isNewFriendWelcomeMessage();
     ErrorCode deleteFriend(String userId, String friendUid, long[] head);
     ErrorCode blackUserRequest(String fromUser, String targetUserId, int status, long[] head);
     FriendData getFriendData(String fromUser, String targetUserId);
@@ -190,6 +193,11 @@ public interface IMessagesStore {
 
     boolean checkChatroomParticipantIdelTime(MemorySessionStore.Session session);
 
+
+    String getApplicationAuthCode(String fromUser, String applicationId, int appType, String host);
+    String verifyApplicationAuthCode(String token, String applicationId, int type);
+    ErrorCode configApplication(String appId, int appType, long timestamp, String nonce, String signature);
+
     ErrorCode getUserSettings(String userId, long version, WFCMessage.GetUserSettingResult.Builder builder);
     WFCMessage.UserSettingEntry getUserSetting(String userId, int scope, String key);
     List<WFCMessage.UserSettingEntry> getUserSetting(String userId, int scope);
@@ -206,10 +214,11 @@ public interface IMessagesStore {
     void clearUserChannels(String userId);
     ErrorCode modifyChannelInfo(String operator, String channelId, int modifyType, String value);
     ErrorCode transferChannel(String operator, String channelId, String newOwner);
-    ErrorCode distoryChannel(String operator, String channelId, boolean isAdmin);
+    ErrorCode destroyChannel(String operator, String channelId, boolean isAdmin);
     List<WFCMessage.ChannelInfo> searchChannel(String keyword, boolean buzzy, int page);
     ErrorCode listenChannel(String operator, String channelId, boolean listen);
     WFCMessage.ChannelInfo getChannelInfo(String channelId);
+    boolean canSendMessageInChannel(String user, String channelId);
     boolean checkUserInChannel(String user, String channelId);
     Collection<String> getChannelSubscriber(String channelId);
 
@@ -224,6 +233,12 @@ public interface IMessagesStore {
     boolean isAllowRobotCustomGroupNotification();
     int getVisibleQuitKickoffNotification();
 
+    int getGroupForbiddenClientOperation();
+
+    boolean isForwardMessageWithClientInfo();
+    boolean isRobotCallbackWithClientInfo();
+    boolean isChannelCallbackWithClientInfo();
+
     List<Integer> getClientForbiddenSendTypes();
     List<Integer> getBlackListExceptionTypes();
     List<Integer> getGroupMuteExceptionTypes();
@@ -236,6 +251,9 @@ public interface IMessagesStore {
 
     //使用了数据库，会比较慢，仅能用户用户/群组等id的生成
     String getShortUUID();
+
+    boolean checkSignature(String signature);
+    boolean existSignatures();
     /**
      * Used to initialize all persistent store structures
      */

broker/src/main/java/io/moquette/spi/impl/MessagesPublisher.java

@@ -16,6 +16,7 @@
 
 package io.moquette.spi.impl;
 
+import cn.wildfirechat.pojos.OutputClient;
 import cn.wildfirechat.pojos.OutputMessageData;
 import cn.wildfirechat.proto.ProtoConstants;
 import cn.wildfirechat.proto.WFCMessage;
@@ -24,7 +25,6 @@ import com.google.gson.Gson;
 import com.hazelcast.core.HazelcastInstance;
 import com.hazelcast.util.StringUtil;
 import cn.wildfirechat.pojos.OutputNotifyChannelSubscribeStatus;
-import cn.wildfirechat.pojos.SendMessageData;
 import com.xiaoleilu.loServer.model.FriendData;
 import io.moquette.persistence.*;
 import io.moquette.persistence.MemorySessionStore.Session;
@@ -35,6 +35,7 @@ import io.moquette.spi.ISessionsStore;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.handler.codec.mqtt.*;
+import win.liyufan.im.GsonUtil;
 import win.liyufan.im.HttpUtils;
 import win.liyufan.im.IMTopic;
 
@@ -160,7 +161,7 @@ public class MessagesPublisher {
         }
     }
 
-    private void publish2Receivers(String sender, int conversationType, String target, int line, long messageId, Collection<String> receivers, String pushContent, String pushData, String exceptClientId, int pullType, int messageContentType, long serverTime, int mentionType, List<String> mentionTargets, int persistFlag) {
+    private void publish2Receivers(String sender, int conversationType, String target, int line, long messageId, Collection<String> receivers, String pushContent, String pushData, String exceptClientId, int pullType, int messageContentType, long serverTime, int mentionType, List<String> mentionTargets, int persistFlag, boolean directing) {
         if (persistFlag == Transparent) {
             publishTransparentMessage2Receivers(messageId, receivers, pullType, exceptClientId);
             return;
@@ -176,10 +177,19 @@ public class MessagesPublisher {
                         if (message == null) {
                             message = m_messagesStore.getMessage(messageId);
                         }
+                        OutputClient outputClient = null;
+                        if(m_messagesStore.isRobotCallbackWithClientInfo() && !StringUtil.isNullOrEmpty(exceptClientId)) {
+                            Session session = m_sessionsStore.getSession(exceptClientId);
+                            if(session != null && session.getUsername().equals(sender)) {
+                                outputClient = new OutputClient(session.getPlatform(), exceptClientId);
+                            }
+                        }
+
                         final WFCMessage.Message finalMsg = message;
+                        OutputClient finalOutputClient = outputClient;
                         Server.getServer().getCallbackScheduler().execute(() -> {
                             try {
-                                HttpUtils.httpJsonPost(robot.getCallback(), new Gson().toJson(SendMessageData.fromProtoMessage(finalMsg), SendMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Robot_Message_Callback);
+                                HttpUtils.httpJsonPost(robot.getCallback(), GsonUtil.gson.toJson(OutputMessageData.fromProtoMessage(finalMsg, finalOutputClient), OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Robot_Message_Callback);
                             } catch (Exception e) {
                                 e.printStackTrace();
                                 Utility.printExecption(LOG, e, EVENT_CALLBACK_Exception);
@@ -191,7 +201,7 @@ public class MessagesPublisher {
             }
             long messageSeq;
             if (pullType != ProtoConstants.PullType.Pull_ChatRoom) {
-                messageSeq = m_messagesStore.insertUserMessages(sender, conversationType, target, line, messageContentType, user, messageId);
+                messageSeq = m_messagesStore.insertUserMessages(sender, conversationType, target, line, messageContentType, user, messageId, directing);
             } else {
                 messageSeq = m_messagesStore.insertChatroomMessages(user, line, messageId);
             }
@@ -595,15 +605,30 @@ public class MessagesPublisher {
     public void publish2Receivers(WFCMessage.Message message, Set<String> receivers, String exceptClientId, int pullType) {
         if (message.getConversation().getType() == ProtoConstants.ConversationType.ConversationType_Channel) {
             WFCMessage.ChannelInfo channelInfo = m_messagesStore.getChannelInfo(message.getConversation().getTarget());
-            if (channelInfo != null && !StringUtil.isNullOrEmpty(channelInfo.getCallback())) {
+            if (channelInfo != null && !StringUtil.isNullOrEmpty(channelInfo.getCallback()) && channelInfo.getAutomatic() == 1 && !message.getFromUser().equals(channelInfo.getOwner())) {
+                OutputClient outputClient = null;
+                if(m_messagesStore.isChannelCallbackWithClientInfo() && !StringUtil.isNullOrEmpty(exceptClientId)) {
+                    Session session = m_sessionsStore.getSession(exceptClientId);
+                    if(session != null && session.getUsername().equals(message.getFromUser())) {
+                        outputClient = new OutputClient(session.getPlatform(), exceptClientId);
+                    }
+                }
+
+                OutputClient finalOutputClient = outputClient;
                 Server.getServer().getCallbackScheduler().execute(() -> {
                     try {
-                        HttpUtils.httpJsonPost(channelInfo.getCallback() + "/message", new Gson().toJson(SendMessageData.fromProtoMessage(message), SendMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Channel_Message_Callback);
+                        HttpUtils.httpJsonPost(channelInfo.getCallback() + "/message", GsonUtil.gson.toJson(OutputMessageData.fromProtoMessage(message, finalOutputClient), OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Channel_Message_Callback);
                     } catch (Exception e) {
                         e.printStackTrace();
                         Utility.printExecption(LOG, e, EVENT_CALLBACK_Exception);
                     }
                 });
+            } else {
+                if (channelInfo == null) {
+                    LOG.info("Channel {} not exist", message.getConversation().getTarget());
+                } else {
+                    LOG.info("Channel {} callback {}", message.getConversation().getTarget(), channelInfo.getCallback());
+                }
             }
         }
         long messageId = message.getMessageId();
@@ -621,12 +646,14 @@ public class MessagesPublisher {
                 pushContent = "[语音]";
             } else if(type == ProtoConstants.ContentType.Video) {
                 pushContent = "[视频]";
-            } else if(type == ProtoConstants.ContentType.RichMedia) {
-                pushContent = "[图文]";
+            } else if(type == ProtoConstants.ContentType.Link) {
+                pushContent = "[链接]";
             } else if(type == ProtoConstants.ContentType.File) {
                 pushContent = "[文件]";
             } else if(type == ProtoConstants.ContentType.Sticker) {
                 pushContent = "[表情]";
+            } else if (type == ProtoConstants.ContentType.Name_Card) {
+                pushContent = "[名片]";
             }
         }
 
@@ -638,14 +665,14 @@ public class MessagesPublisher {
                     message.getConversation().getType(), message.getConversation().getTarget(), message.getConversation().getLine(),
                     messageId,
                     receivers,
-                    pushContent, message.getContent().getPushData(), exceptClientId, pullType, message.getContent().getType(), message.getServerTimestamp(), message.getContent().getMentionedType(), message.getContent().getMentionedTargetList(), message.getContent().getPersistFlag());
+                    pushContent, message.getContent().getPushData(), exceptClientId, pullType, message.getContent().getType(), message.getServerTimestamp(), message.getContent().getMentionedType(), message.getContent().getMentionedTargetList(), message.getContent().getPersistFlag(), message.hasToUser() || !message.getToList().isEmpty());
 
     }
 
-    public void forwardMessage(final WFCMessage.Message message, String forwardUrl) {
+    public void forwardMessage(final WFCMessage.Message message, String forwardUrl, OutputClient outputClient) {
         Server.getServer().getCallbackScheduler().execute(() -> {
             try {
-                HttpUtils.httpJsonPost(forwardUrl, new Gson().toJson(OutputMessageData.fromProtoMessage(message), OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Forward_Message_Callback);
+                HttpUtils.httpJsonPost(forwardUrl, GsonUtil.gson.toJson(OutputMessageData.fromProtoMessage(message, outputClient), OutputMessageData.class), HttpUtils.HttpPostType.POST_TYPE_Forward_Message_Callback);
             } catch (Exception e) {
                 e.printStackTrace();
                 Utility.printExecption(LOG, e, EVENT_CALLBACK_Exception);
@@ -655,7 +682,7 @@ public class MessagesPublisher {
 
     public void forwardMessageWithCallback(final WFCMessage.Message message, String forwardUrl, HttpUtils.HttpCallback callback) {
         try {
-            HttpUtils.httpJsonPost(forwardUrl, new Gson().toJson(OutputMessageData.fromProtoMessage(message), OutputMessageData.class), new HttpUtils.HttpCallback() {
+            HttpUtils.httpJsonPost(forwardUrl, GsonUtil.gson.toJson(OutputMessageData.fromProtoMessage(message), OutputMessageData.class), new HttpUtils.HttpCallback() {
                 @Override
                 public void onSuccess(String content) {
                     Server.getServer().getImBusinessScheduler().execute(()->{
@@ -677,13 +704,13 @@ public class MessagesPublisher {
     }
 
     public void notifyChannelListenStatusChanged(WFCMessage.ChannelInfo channelInfo, String user, boolean listen) {
-        if (channelInfo == null || StringUtil.isNullOrEmpty(channelInfo.getCallback())) {
+        if (channelInfo == null || StringUtil.isNullOrEmpty(channelInfo.getCallback()) || channelInfo.getAutomatic() == 0) {
             return;
         }
 
         Server.getServer().getCallbackScheduler().execute(() -> {
             try {
-                HttpUtils.httpJsonPost(channelInfo.getCallback() + "/subscribe", new Gson().toJson(new OutputNotifyChannelSubscribeStatus(user, channelInfo.getTargetId(), listen), OutputNotifyChannelSubscribeStatus.class), HttpUtils.HttpPostType.POST_TYPE_Channel_Subscriber_Event_Callback);
+                HttpUtils.httpJsonPost(channelInfo.getCallback() + "/subscribe", GsonUtil.gson.toJson(new OutputNotifyChannelSubscribeStatus(user, channelInfo.getTargetId(), listen), OutputNotifyChannelSubscribeStatus.class), HttpUtils.HttpPostType.POST_TYPE_Channel_Subscriber_Event_Callback);
             } catch (Exception e) {
                 e.printStackTrace();
                 Utility.printExecption(LOG, e, EVENT_CALLBACK_Exception);

broker/src/main/java/io/moquette/spi/impl/ProtocolProcessor.java

@@ -43,10 +43,12 @@ import io.netty.handler.codec.mqtt.*;
 import io.netty.handler.timeout.IdleStateHandler;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import win.liyufan.im.GsonUtil;
 import win.liyufan.im.HttpUtils;
 import win.liyufan.im.IMTopic;
 import win.liyufan.im.Utility;
 
+import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -106,7 +108,7 @@ public class ProtocolProcessor {
                 ConnectionDescriptor descriptor = connectionDescriptors.getConnection(session.getClientID());
                 try {
                     if (descriptor != null) {
-                        processDisconnect(descriptor.getChannel(), true, false);
+                        processDisconnect(descriptor.getChannel(), false, false);
                     }
                 } catch (InterruptedException e) {
                     e.printStackTrace();
@@ -264,7 +266,7 @@ public class ProtocolProcessor {
         if (!StringUtil.isNullOrEmpty(mUserOnlineStatusCallback)) {
             mServer.getCallbackScheduler().execute(() -> {
                 try {
-                    HttpUtils.httpJsonPost(mUserOnlineStatusCallback, new Gson().toJson(new UserOnlineStatus(userId, clientId, platform, status, packageName)), HttpUtils.HttpPostType.POST_TYPE_User_Online_Event_Callback);
+                    HttpUtils.httpJsonPost(mUserOnlineStatusCallback, GsonUtil.gson.toJson(new UserOnlineStatus(userId, clientId, platform, status, packageName)), HttpUtils.HttpPostType.POST_TYPE_User_Online_Event_Callback);
                 } catch (Exception e) {
                     e.printStackTrace();
                     Utility.printExecption(LOG, e, EVENT_CALLBACK_Exception);
@@ -307,7 +309,7 @@ public class ProtocolProcessor {
             }
             byte[] pwd = null;
             if (msg.variableHeader().hasPassword()) {
-                pwd = msg.payload().password();
+                pwd = msg.payload().passwordInBytes();
 
                 MemorySessionStore.Session session = m_sessionsStore.getSession(clientId);
                 if (session == null) {
@@ -338,6 +340,24 @@ public class ProtocolProcessor {
                     failedCredentials(channel);
                     return false;
                 }
+
+                if(session.getPlatform() == ProtoConstants.Platform.Platform_Android || session.getPlatform() == ProtoConstants.Platform.Platform_APad) {
+                    byte[] signature = msg.payload().signatureInBytes();
+                    String basedSign = null;
+                    if (signature != null && signature.length > 0) {
+                        signature = AES.AESDecrypt(signature, session.getSecret(), true);
+                    }
+                    if (signature != null && signature.length > 0) {
+                        basedSign = Base64.getEncoder().encodeToString(signature);
+                    }
+
+                    if (!m_messagesStore.checkSignature(basedSign)) {
+                        LOG.error("Bad signature of session <{}, {}>", session.getUsername(), session.getClientID());
+                        failedBadSignature(channel);
+                        return false;
+                    }
+                }
+
                 session.setMqttVersion(mqttVersion);
             } else {
                 LOG.error("Client didn't supply any password and MQTT anonymous mode is disabled CId={}", clientId);
@@ -445,6 +465,11 @@ public class ProtocolProcessor {
         LOG.info("Client {} failed to connect with bad username or password.", session);
     }
 
+    private void failedBadSignature(Channel session) {
+        session.writeAndFlush(connAck(CONNECTION_REFUSED_SIGNATURE_FAILURE));
+        LOG.info("Client {} failed to connect with bad signature.", session);
+    }
+
     private void setIdleTime(ChannelPipeline pipeline, int idleTime) {
         if (pipeline.names().contains("idleStateHandler")) {
             pipeline.remove("idleStateHandler");
@@ -583,8 +608,9 @@ public class ProtocolProcessor {
         channel.closeFuture();
 
         //disconnect the session
-
-        m_sessionsStore.sessionForClient(clientID).disconnect(session.getUsername(), isDup, isRetain);
+        if(session != null) {
+            m_sessionsStore.sessionForClient(clientID).disconnect(session.getUsername(), isDup, isRetain);
+        }
     }
 
 
@@ -619,17 +645,40 @@ public class ProtocolProcessor {
 
         String username = NettyUtils.userName(channel);
         MemorySessionStore.Session session = m_sessionsStore.getSession(clientID);
+        if(session != null) {
+            processOffline(session, clearSession, () -> {
+                ConnectionDescriptor oldConnDescr = new ConnectionDescriptor(clientID, channel);
+                if(connectionDescriptors.removeConnection(oldConnDescr)) {
+                    m_interceptor.notifyClientConnectionLost(clientID, username);
+                }
+                try {
+                    channel.close();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            });
+        } else {
+            ConnectionDescriptor oldConnDescr = new ConnectionDescriptor(clientID, channel);
+            if(connectionDescriptors.removeConnection(oldConnDescr)) {
+                m_interceptor.notifyClientConnectionLost(clientID, username);
+            }
+            try {
+                channel.close();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public void processOffline(MemorySessionStore.Session session, boolean logout, Runnable runnable) {
         if(session != null) {
             session.refreshLastActiveTime();
-            forwardOnlineStatusEvent(username, clientID, session.getPlatform(), clearSession ? UserOnlineStatus.LOGOUT : UserOnlineStatus.OFFLINE, session.getAppName());
+            forwardOnlineStatusEvent(session.getUsername(), session.getClientID(), session.getPlatform(), logout ? UserOnlineStatus.LOGOUT : UserOnlineStatus.OFFLINE, session.getAppName());
+            if(runnable != null) {
+                runnable.run();
+            }
             m_messagesStore.updateUserOnlineSetting(session, false);
         }
-
-        ConnectionDescriptor oldConnDescr = new ConnectionDescriptor(clientID, channel);
-        if(connectionDescriptors.removeConnection(oldConnDescr)) {
-            m_interceptor.notifyClientConnectionLost(clientID, username);
-        }
-
     }
 
     /**

broker/src/main/java/io/moquette/spi/impl/Qos1PublishHandler.java

@@ -57,6 +57,7 @@ import io.netty.handler.codec.mqtt.MqttFixedHeader;
 import io.netty.handler.codec.mqtt.MqttMessageType;
 import io.netty.handler.codec.mqtt.MqttPublishMessage;
 import cn.wildfirechat.common.ErrorCode;
+import win.liyufan.im.GsonUtil;
 import win.liyufan.im.IMTopic;
 import win.liyufan.im.RateLimiter;
 import win.liyufan.im.Utility;
@@ -142,7 +143,7 @@ public class Qos1PublishHandler extends QosPublishHandler {
                 out.addSession(userId, session.getClientID(), session.getPlatform(), status, session.getLastActiveTime());
             }
 
-            callback.onRouteHandled(new Gson().toJson(out).getBytes());
+            callback.onRouteHandled(GsonUtil.gson.toJson(out).getBytes());
         });
     }
 
@@ -163,16 +164,19 @@ public class Qos1PublishHandler extends QosPublishHandler {
                         } else {
                             MemorySessionStore.Session session = m_sessionStore.getSession(clientID);
                             if (session != null && session.getUsername().equals(fromUser)) {
-                                if (data.length > 7*1024 && session.getMqttVersion().protocolLevel() >= MqttVersion.Wildfire_1.protocolLevel()) {
+                                if (data.length > 7*1024 && session.getMqttVersion().protocolLevel() >= MqttVersion.MQTT_5.protocolLevel()) {
                                     ByteArrayOutputStream out = new ByteArrayOutputStream();
-                                    GZIPOutputStream gzip;
+                                    GZIPOutputStream gzip = null;
                                     try {
                                         gzip = new GZIPOutputStream(out);
                                         gzip.write(data);
-                                        gzip.close();
                                     } catch (Exception e) {
                                         e.printStackTrace();
                                         Utility.printExecption(LOG, e);
+                                    } finally {
+                                        if(gzip != null) {
+                                            gzip.close();
+                                        }
                                     }
                                     data = out.toByteArray();
                                     code = (byte)ErrorCode.ERROR_CODE_SUCCESS_GZIPED.code;
@@ -248,6 +252,13 @@ public class Qos1PublishHandler extends QosPublishHandler {
         
         MemorySessionStore.Session session = m_sessionStore.getSession(clientID);
         payloadContent = AES.AESDecrypt(payloadContent, session.getSecret(), true);
+        if(payloadContent == null) {
+            ByteBuf ackPayload = Unpooled.buffer();
+            ackPayload.ensureWritable(1).writeByte(ERROR_CODE_INVALID_DATA.getCode());
+            sendPubAck(clientID, messageID, ackPayload, ERROR_CODE_INVALID_DATA);
+            return;
+        }
+
         imHandler(clientID, username, imtopic, payloadContent, (errorCode, ackPayload) -> sendPubAck(clientID, messageID, ackPayload, errorCode), ProtoConstants.RequestSourceType.Request_From_User);
     }
 

broker/src/main/java/io/netty/handler/codec/mqtt/MqttCodecUtil.java

@@ -5,7 +5,7 @@
  * version 2.0 (the "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at:
  *
- *   http://www.apache.org/licenses/LICENSE-2.0
+ *   https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@@ -16,13 +16,30 @@
 
 package io.netty.handler.codec.mqtt;
 
+import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.DecoderException;
+import io.netty.util.Attribute;
+import io.netty.util.AttributeKey;
 
 final class MqttCodecUtil {
 
     private static final char[] TOPIC_WILDCARDS = {'#', '+'};
-    private static final int MIN_CLIENT_ID_LENGTH = 1;
-    private static final int MAX_CLIENT_ID_LENGTH = 23;
+
+    static final AttributeKey<MqttVersion> MQTT_VERSION_KEY = AttributeKey.valueOf("NETTY_CODEC_MQTT_VERSION");
+
+    static MqttVersion getMqttVersion(ChannelHandlerContext ctx) {
+        Attribute<MqttVersion> attr = ctx.channel().attr(MQTT_VERSION_KEY);
+        MqttVersion version = attr.get();
+        if (version == null) {
+            return MqttVersion.MQTT_3_1_1;
+        }
+        return version;
+    }
+
+    static void setMqttVersion(ChannelHandlerContext ctx, MqttVersion version) {
+        Attribute<MqttVersion> attr = ctx.channel().attr(MQTT_VERSION_KEY);
+        attr.set(version);
+    }
 
     static boolean isValidPublishTopicName(String topicName) {
         // publish topic name must not contain any wildcard
@@ -38,20 +55,20 @@ final class MqttCodecUtil {
         return messageId != 0;
     }
 
-    static boolean isValidClientId(MqttVersion mqttVersion, String clientId) {
+    static boolean isValidClientId(MqttVersion mqttVersion, int maxClientIdLength, String clientId) {
         if (mqttVersion == MqttVersion.MQTT_3_1) {
-            return clientId != null && clientId.length() >= MIN_CLIENT_ID_LENGTH &&
-                clientId.length() <= MAX_CLIENT_ID_LENGTH;
+            return clientId != null && clientId.length() >= MqttConstant.MIN_CLIENT_ID_LENGTH &&
+                clientId.length() <= maxClientIdLength;
         }
         if (mqttVersion.protocolLevel() >= MqttVersion.MQTT_3_1_1.protocolLevel()) {
-            // In 3.1.3.1 Client Identifier of MQTT 3.1.1 specification, The Server MAY allow ClientId’s
+            // In 3.1.3.1 Client Identifier of MQTT 3.1.1 and 5.0 specifications, The Server MAY allow ClientId’s
             // that contain more than 23 encoded bytes. And, The Server MAY allow zero-length ClientId.
             return clientId != null;
         }
         throw new IllegalArgumentException(mqttVersion + " is unknown mqtt version");
     }
 
-    static MqttFixedHeader validateFixedHeader(MqttFixedHeader mqttFixedHeader) {
+    static MqttFixedHeader validateFixedHeader(ChannelHandlerContext ctx, MqttFixedHeader mqttFixedHeader) {
         switch (mqttFixedHeader.messageType()) {
             case PUBREL:
             case SUBSCRIBE:
@@ -59,6 +76,12 @@ final class MqttCodecUtil {
                 if (mqttFixedHeader.qosLevel() != MqttQoS.AT_LEAST_ONCE) {
                     throw new DecoderException(mqttFixedHeader.messageType().name() + " message must have QoS 1");
                 }
+                return mqttFixedHeader;
+            case AUTH:
+                if (MqttCodecUtil.getMqttVersion(ctx) != MqttVersion.MQTT_5) {
+                    throw new DecoderException("AUTH message requires at least MQTT 5");
+                }
+                return mqttFixedHeader;
             default:
                 return mqttFixedHeader;
         }
@@ -75,7 +98,7 @@ final class MqttCodecUtil {
             case UNSUBACK:
             case PINGREQ:
             case PINGRESP:
-            //case DISCONNECT:
+            case DISCONNECT:
                 if (mqttFixedHeader.isDup() ||
                         mqttFixedHeader.qosLevel() != MqttQoS.AT_MOST_ONCE ||
                         mqttFixedHeader.isRetain()) {

broker/src/main/java/io/netty/handler/codec/mqtt/MqttConnAckMessage.java

@@ -5,7 +5,7 @@
  * version 2.0 (the "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at:
  *
- *   http://www.apache.org/licenses/LICENSE-2.0
+ *   https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@@ -17,7 +17,7 @@
 package io.netty.handler.codec.mqtt;
 
 /**
- * See <a href="http://public.dhe.ibm.com/software/dw/webservices/ws-mqtt/mqtt-v3r1.html#connack">MQTTV3.1/connack</a>
+ * See <a href="https://public.dhe.ibm.com/software/dw/webservices/ws-mqtt/mqtt-v3r1.html#connack">MQTTV3.1/connack</a>
  */
 public final class MqttConnAckMessage extends MqttMessage {
 
@@ -28,7 +28,7 @@ public final class MqttConnAckMessage extends MqttMessage {
     public MqttConnAckMessage(MqttFixedHeader mqttFixedHeader, MqttConnAckVariableHeader variableHeader, MqttConnectAckPayload payload) {
         super(mqttFixedHeader, variableHeader, payload);
     }
-
+    
     @Override
     public MqttConnAckVariableHeader variableHeader() {
         return (MqttConnAckVariableHeader) super.variableHeader();

broker/src/main/java/io/netty/handler/codec/mqtt/MqttConnAckVariableHeader.java

@@ -5,7 +5,7 @@
  * version 2.0 (the "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at:
  *
- *   http://www.apache.org/licenses/LICENSE-2.0
+ *   https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@@ -27,9 +27,17 @@ public final class MqttConnAckVariableHeader {
 
     private final boolean sessionPresent;
 
+    private final MqttProperties properties;
+
     public MqttConnAckVariableHeader(MqttConnectReturnCode connectReturnCode, boolean sessionPresent) {
+        this(connectReturnCode, sessionPresent, MqttProperties.NO_PROPERTIES);
+    }
+
+    public MqttConnAckVariableHeader(MqttConnectReturnCode connectReturnCode, boolean sessionPresent,
+                                     MqttProperties properties) {
         this.connectReturnCode = connectReturnCode;
         this.sessionPresent = sessionPresent;
+        this.properties = MqttProperties.withEmptyDefaults(properties);
     }
 
     public MqttConnectReturnCode connectReturnCode() {
@@ -40,6 +48,10 @@ public final class MqttConnAckVariableHeader {
         return sessionPresent;
     }
 
+    public MqttProperties properties() {
+        return properties;
+    }
+
     @Override
     public String toString() {
         return new StringBuilder(StringUtil.simpleClassName(this))