三棵杏软件工作室 | 录播服务器产品三棵杏流水账软件(含备忘精灵) PJSIP协议栈移植开发专家

SIP协议学习总结

2012.08.24

SIP对应关系

注册命令(信令)
REGISTER registers the address listed in the To header field with a SIP server
由UA向注册服务器请求To字段中带的SIP地址

200 ok or other error code from server

第1对命令
SUBSCRIBE request current state and state updates from a remote node.
NOTIFY used to notify a SIP node that an event which has been requested by an earlier SUBSCRIBE method has occurred

第2对命令
INVITE indicates that the user or service is being invited to participate in a session
ACK confirms that the client has received a final[......]

阅读全文

wordpress代码显示插件CodeColorer属性列表

2012.08.22

lang (string) – 代码使用的语言。
tab_size (integer) – 用以替换制表符的空格数，可在设置界面更改。
line_numbers (boolean) – 是否显示行号，可在设置界面更改。
first_line (integer) – 指定代码块第一行的行号
highlight (string) – 用于指定整行高亮的代码行行数，参数是用半角逗号分隔的数字串(如 1,5,8,9)。
no_links (boolean) – 当值为false时，关键字将会添加一个到官方文档的链接，可在设置界面更改。
lines (integer) –指定代码块显示的行数，当值设置为-1时，不出现纵向滚动条，可在设置界面更改。
width (integer or string) – 代码块宽度，可在设置界面更改。
height (integer or string) – 代码块高度，当这个高度可显示的行数比lines指定的值大才会生效，可在设置界面更改。
rss_width (integer or string) – 代码块在RSS输出时的宽度，可在设置界面更改。[......]

阅读全文

wordpress 3.1 如何在评论中显示IP地址

2012.08.22

看到很多博客和论坛都可以显示IP地址，很羡慕，于是想在自己的博客中也显示IP，网上没找到现成的方法，通过几个小时的试验，终于在评论列表中出现了IP地址。特把成果帖出来，不敢藏私！

1.打开文件wp-includes/comment-template.php

2.增加php函数到该文件中

function get_comment_author_IP2( $comment_ID = 0 ) {

$comment = get_comment( $comment_ID );

$IP = $comment->comment_author_IP;

$pos = strpos($IP, '.', 0);

$IP[$pos - 1] = '*';

$patterns = "/\.[0-9]*$/";

$IP = preg_replace($patterns, '.*', $IP);

return 'IP: ' . $IP;

}

3.找到以下行修改

修改前：

;
;
;
printf( __('%1$s at %2$s'), get_comment_date(), get_comment_time())xxx);
;
;
;

修改后:

;
;
;

printf( __('%1$s at %2$s %3$s'), get_comment_date(), get_comment_time(), get_comment_author_IP2()) xxx);
;
;
;

注意第2,3点中的xxx表示省略了该行尾部的一些无关字符串

牢牢把住财富的水龙头——从记账开始

2012.08.22

摘自《富起来的秘密》

　　孙子有云“知己知彼，百战不殆”，而理财就是和财富博弈的过程。首先，我们要清楚自己手中的财富，才能够对这些财富进行调整和规划。那么，你知道自己有多少存款，知道自己的动产不动产总额，每月的收入以及详细的支出状况吗？你清楚每月的花费哪些是必要，哪些是可削减的吗？你清楚自己究竟有多少Money可以用来投资吗？相信如果有记账习惯的人，拿出手边的笔记本或打开电脑的记账软件，一定能详细回答这些问题。那些没有记账习惯的人，脑中就只有一片混乱和疑惑了。

　　理财，仅仅靠着一份理财计划是没有用的，如果连自己的财务状况都没有办法搞清楚，你就没办法进行财务计划，遇到财务问题只能拆东墙补西墙。所以，理财的第一步，首先从记账开始。养成良好的记账习惯，进行持续、条理、准确的财务记录，才能准确衡量自己所处的经济地位，从而制订合理的理财计划。

　　记账，说简单也简单，一支笔一个本子(有条件的电脑里装一个记账软件)，任何人都可以记账。但说难其实也难，大多数人开始记账，往往都是三天打鱼两天晒网，坚持不了多久就嫌麻烦而放弃了。其实，记账也有一些小技巧，学会了记账的小技巧，可以让你轻松养成记账的习惯。

　[......]

阅读全文

三棵杏备忘精灵(提醒软件)使用场景说明

2012.08.19

自由的互联网，不自由的内容审核

2012.08.18

在中国的今时今日,互联网为言论自由立下了汗马功劳。国外有舆论认为丁关根为中国互联网的开放做出了贡献。随着微博的兴起，更是随时随地可以发表言论，指点江山，激扬文字。然而自由是相对的，无论任何网站博客论坛言论，都必须过编辑审核这一关。
如果从保护知识产权角度来说，初步觉得很必要审核，但是，知识产品的保护其实最终只能由知识产品法律来保护，而无关审核。于似乎，只能从管制的角度来考虑：政府要管制互联网的言论，不能有反党反政府，反主流的言论。上有所好，下必行效！互联网公司为了自身的利益考虑，审核又会加码，不允许博客或论坛帖中有带广告性质的文字，图片或链接，博客发表，因为这涉及到公司自身的利益–想要广告，请联系付费！一张禁锢中国互联网自由的网就这样在无形中布起来了。

这个结论不是胡编瞎诌，作者有切身体会。在百度问答上面回答问题，如果带有URL链接，大都会不管你的答案是否符合提问，先会被pass掉。在CSDN上，不能发表任何宣传产品和广告相关的博文，博客会被立即删除。恶行累累，不胜枚举。这些当今的互联网老大，似乎忘记了当初自己是怎么长大的。为什么中国互联网没有创新，[......]

阅读全文

支持农历(阴历)的提醒软件下载

2012.08.17

三棵杏备忘精灵，具备多种方式提醒：每年一次(提醒亲人生日），每月一次，每周一次（提醒周例会），每周工作日（下班时刻提醒打卡)，每天间隔时间(循环提醒，提醒喝水），每周工作日间隔时间（循环提醒），指定节日提醒等强大实用的功能！日期设置同时支持农历（阴历）和阳历，界面简单好用，可以查看本周内将要发生的事件，下周将要发生的事件，本月将要发生的事件，下月将要发生的事件。总之，是一个不可多得实用的提醒软件，永久免费免注册。

下载地址：http://www.mworkbox.com/wp/3almond/36.html

注意事项：三棵杏备忘精灵是嵌入在三棵杏流水账软件中的一个模块，二者是同一个软件！二合一买一送一，哈哈，全部免费，免注册！

下载页面同时有软件使用说明文档下载，文档浅显易懂。

名人美容小秘诀

2012.08.17

—————————
宋慧乔美容秘诀：最爱柠檬汁绝不碰可乐
●人参茶和柠檬汁是大爱巧克力和可乐坚决out!
饮食平时少吃巧克力、可乐、红茶这些刺激性的东西，除了多吃水果，平常也可以补充一些复合维生素；养颜美容的饮料可以多喝，比如人参茶和柠檬汁，人参的养分可以加速血液循环，有红润脸色的功效，而柠檬具有美白作用。从里到外才能强化美白。

●搽美白精华是每天必做功课
日常保养的程序要正确，比如找到适合自己的保养品，每天敷美白面膜，勤搽美白精华液是我不管多累都一定要做的功课，只有这样才能迅速恢复原本白皙的模样。

●鸡蛋、牛奶让你自然美白
给大家推荐两个“土方”，就是鸡蛋和牛奶美白法。将新鲜鸡蛋与蜂蜜搅和均匀后涂在面部，10分钟用清水洗干净，每周两次就可以了，蛋清可以促进血液循环，蛋黄里面的卵磷脂、甘油三脂和卵黄素，是很多美白产品中都含有的元素；另外就是用牛奶洗脸，不仅可以使皮肤变得滑滑的，香味也不错噢。

————————————————
护肤：张韶涵独特水果美容秘诀

听到大家夸自己的[......]

阅读全文

三棵杏流水账软件诞生记—要做中国第一家庭流水账软件

2012.08.16

大概做IT的人，我想每个人都曾经有过创业的梦想，那既然有这个梦，趁年轻的时候，为什么不去拼搏一把呢？虽然未曾有”现在不做什么时候做”的紧迫感，也没有”你不做谁做”的舍我其谁的责任感。这是个美好的世界，因为我们赶上了信息革命时代，互联网信息爆炸时代。这是个坏的时代，信息太多，发展太快，应接不暇，诱惑太多太容易迷茫！同时这也是个英雄辈出的时代。英特网的弄潮儿是张朝阳、李宏彦、马化腾、丁磊、曹国伟等，电子商务的翘楚属于刘强东，马云等。其他领域诸于周鸿祎、雷军、邹胜龙、古永锵等。我辈小民虽不妄想有这些前辈们的成绩，但在一些细分领域，还是大有一番可为的。比方说在一些细分领域，只要能够满足一些人的特点需求，提供特定的优良的服务，就一定可以找到创业的切入点。

创业之前，首先要明白自己的长处和短处，扬长避短。拿我个人来说，技术是强项，知识面比较广，但市场是弱项。我为什么选择做三棵杏流水账软件呢，启发点是内子有记账的习惯，都用笔记录在本子上，每个月要一项一项累加统计。我就上网搜了一下流水账软件虽多，但很多要么太简陋，要么太复杂只适合公司用。调研的结果是流水账软件有市场空白！有句经商名言[......]

阅读全文

MD5算法的C++类，源码来源互联网

2012.08.12

类的用法:

MD5 stMd5;
string sMyContent = "123xxxxxxxxxx";
stMd5.update(sMyContent.c_str(), sMyContent.size());
printf("md5=%s", stMd5.toString().c_str());

附上类的源码

//md5.h
#pragma once

#include <string>
#include <fstream>

/* Type define */
typedef unsigned char byte;
typedef unsigned int uint32;

using std::string;
using std::ifstream;

/* MD5 declaration. */
class MD5 {
public:
MD5();
MD5(const void* input, size_t length);
MD5(const string& str);
MD5(ifstream& in);
void update(const void* input, size_t length);
void update(const string& str);
void update(ifstream& in);
const byte* digest();
string toString();
void reset();

private:
void update(const byte* input, size_t length);
void final();
void transform(const byte block[64]);
void encode(const uint32* input, byte* output, size_t length);
void decode(const byte* input, uint32* output, size_t length);
string bytesToHexString(const byte* input, size_t length);

/* class uncopyable */
MD5(const MD5&);
MD5& operator=(const MD5&);

private:
uint32 _state[4]; /* state (ABCD) */
uint32 _count[2]; /* number of bits, modulo 2^64 (low-order word first) */
byte _buffer[64]; /* input buffer */
byte _digest[16]; /* message digest */
bool _finished; /* calculate finished ? */

static const byte PADDING[64]; /* padding for calculate */
static const char HEX[16];
enum { BUFFER_SIZE = 1024 };
};

md5.cpp文件

//md5.cpp
//#include "stdafx.h"
#include "md5.h"

using namespace std;

/* Constants for MD5Transform routine. */
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21

/* F, G, H and I are basic MD5 functions.
*/
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))

/* ROTATE_LEFT rotates x left n bits.
*/
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
Rotation is separate from addition to prevent recomputation.
*/
#define FF(a, b, c, d, x, s, ac) { \
(a) += F ((b), (c), (d)) + (x) + ac; \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + ac; \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + ac; \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + ac; \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}

const byte MD5::PADDING[64] = { 0x80 };
const char MD5::HEX[16] = {
'0', '1', '2', '3',
'4', '5', '6', '7',
'8', '9', 'a', 'b',
'c', 'd', 'e', 'f'
};

/* Default construct. */
MD5::MD5() {
reset();
}

/* Construct a MD5 object with a input buffer. */
MD5::MD5(const void* input, size_t length) {
reset();
update(input, length);
}

/* Construct a MD5 object with a string. */
MD5::MD5(const string& str) {
reset();
update(str);
}

/* Construct a MD5 object with a file. */
MD5::MD5(ifstream& in) {
reset();
update(in);
}

/* Return the message-digest */
const byte* MD5::digest() {

if (!_finished) {
_finished = true;
final();
}
return _digest;
}

/* Reset the calculate state */
void MD5::reset() {

_finished = false;
/* reset number of bits. */
_count[0] = _count[1] = 0;
/* Load magic initialization constants. */
_state[0] = 0x67452301;
_state[1] = 0xefcdab89;
_state[2] = 0x98badcfe;
_state[3] = 0x10325476;
}

/* Updating the context with a input buffer. */
void MD5::update(const void* input, size_t length) {
reset();
update((const byte*)input, length);
}

/* Updating the context with a string. */
void MD5::update(const string& str) {
reset();
update((const byte*)str.c_str(), str.length());
}

/* Updating the context with a file. */
void MD5::update(ifstream& in) {

if (!in) {
return;
}

std::streamsize length;
char buffer[BUFFER_SIZE];
while (!in.eof()) {
in.read(buffer, BUFFER_SIZE);
length = in.gcount();
if (length > 0) {
update(buffer, length);
}
}
in.close();
}

/* MD5 block update operation. Continues an MD5 message-digest
operation, processing another message block, and updating the
context.
*/
void MD5::update(const byte* input, size_t length) {

uint32 i, index, partLen;

_finished = false;

/* Compute number of bytes mod 64 */
index = (uint32)((_count[0] >> 3) & 0x3f);

/* update number of bits */
if ((_count[0] += ((uint32)length << 3)) < ((uint32)length << 3)) {
++_count[1];
}
_count[1] += ((uint32)length >> 29);

partLen = 64 - index;

/* transform as many times as possible. */
if (length >= partLen) {

memcpy(&_buffer[index], input, partLen);
transform(_buffer);

for (i = partLen; i + 63 < length; i += 64) {
transform(&input[i]);
}
index = 0;

} else {
i = 0;
}

/* Buffer remaining input */
memcpy(&_buffer[index], &input[i], length - i);
}

/* MD5 finalization. Ends an MD5 message-_digest operation, writing the
the message _digest and zeroizing the context.
*/
void MD5::final() {

byte bits[8];
uint32 oldState[4];
uint32 oldCount[2];
uint32 index, padLen;

/* Save current state and count. */
memcpy(oldState, _state, 16);
memcpy(oldCount, _count, 8);

/* Save number of bits */
encode(_count, bits, 8);

/* Pad out to 56 mod 64. */
index = (uint32)((_count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
update(PADDING, padLen);

/* Append length (before padding) */
update(bits, 8);

/* Store state in digest */
encode(_state, _digest, 16);

/* Restore current state and count. */
memcpy(_state, oldState, 16);
memcpy(_count, oldCount, 8);
}

/* MD5 basic transformation. Transforms _state based on block. */
void MD5::transform(const byte block[64]) {

uint32 a = _state[0], b = _state[1], c = _state[2], d = _state[3], x[16];

decode(block, x, 64);

/* Round 1 */
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */

/* Round 2 */
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

/* Round 3 */
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */

/* Round 4 */
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */

_state[0] += a;
_state[1] += b;
_state[2] += c;
_state[3] += d;
}

/* Encodes input (ulong) into output (byte). Assumes length is
a multiple of 4.
*/
void MD5::encode(const uint32* input, byte* output, size_t length) {

for (size_t i = 0, j = 0; j < length; ++i, j += 4) {
output[j]= (byte)(input[i] & 0xff);
output[j + 1] = (byte)((input[i] >> 8) & 0xff);
output[j + 2] = (byte)((input[i] >> 16) & 0xff);
output[j + 3] = (byte)((input[i] >> 24) & 0xff);
}
}

/* Decodes input (byte) into output (ulong). Assumes length is
a multiple of 4.
*/
void MD5::decode(const byte* input, uint32* output, size_t length) {

for (size_t i = 0, j = 0; j < length; ++i, j += 4) {
output[i] = ((uint32)input[j]) | (((uint32)input[j + 1]) << 8) |
(((uint32)input[j + 2]) << 16) | (((uint32)input[j + 3]) << 24);
}
}

/* Convert byte array to hex string. */
string MD5::bytesToHexString(const byte* input, size_t length) {

string str;
str.reserve(length << 1);
for (size_t i = 0; i < length; ++i) {
int t = input[i];
int a = t / 16;
int b = t % 16;
str.append(1, HEX[a]);
str.append(1, HEX[b]);
}
return str;
}

/* Convert digest to string value */
string MD5::toString() {
return bytesToHexString(digest(), 16);
}