Unwake's Blog

WinVista分为6个版本

郭清源 — Tue, 13 Jun 2006 16:10:00 GMT

2月19日消息，据外电报道，尽管微软尚未公开新一代操作系统Windows Vista的发布日期，但已经基本确定的是，Vista系统共分为六个版本。

　　据微软网站显示，微软将发布六个版本的Windows Vista系统，分别为：Windows Starter 2007（初级版）、Windows Vista Enterprise（企业版）、Windows Vista Home Basic（家庭基础版）、Windows Vista Home Premium（家庭高级版）、Windows Vista ultimate（终极版）和Windows Vista Business（商业版）。

　　除此之外，微软还将针对欧盟发布两款不捆绑Media Player播放器的“瘦身”版Vista系统，分别为

　　Windows Vista Home Basic N（家庭基础版N）和Windows Vista Business N（商业基础版N）。N代表没有捆绑Media Player播放器。对此，有分析人士指出，在这六大版本中，不包含Windows Vista小企业版本。因此有人猜测，这六个版

　　本可能是Vista版本计划中的一部分。另外，关于初级版Windows Starter 2007，是否与微软针对个别发展中国家而推出的Windows XP Starter Edition简化版系统同出一辙，目前尚不得而知。

　　对于该报道，微软并未发表任何官方评论。在今年年初的CES展会上，比尔-盖茨只是称，Windows Vista将于今年发布，但并未透露确切的发布日期。但据业内人士预计，Windows Vista可能于11月30日或12月1日发布。

给大家推荐一个手机管理器.

郭清源 — Tue, 13 Jun 2006 11:56:00 GMT

以前就用了,不过苦于没有注册码.一个很不错的软件
http://202.113.227.137/tuanwei/unwake/downloads/mobiledit.rar

多媒体信息业务（MMS）互通技术分析

郭清源 — Tue, 06 Jun 2006 11:17:00 GMT

　　多媒体信息业务是MMS的中文名称（Multimedia Messaging Service）。多媒体信息是以WAP无线应用协议为载体，通过移动运营商的GPRS网络，传送包括文字、图像、声音等各种多媒体格式的信息,实现即时的手机端到端、手机终端到互联网或互联网到手机终端的多媒体信息传送。2001年3月，瑞典爱立信公司在法国戛纳发送了世界第一条多媒体信息，此后MMS便受到了众多终端厂商、设备制造商和移动运营商的追捧。

一、MMS的系统结构

　　MMS系统主要包括多媒体信息中心(MMSC，Multimedia Messaging Service Center)、WAP(Wireless Application Protocol)网关和增值服务(VAS， Value Added Services)系统等。其中， MMSC是多媒体消息网络的核心。

　　MMSC由MMS服务器、MMS中继、信息存储器和数据库组成。MMSC提供存储和操作支持，允许终端到终端和终端到电子邮件的即时多媒体信息传送，同时支持灵活的寻址能力。MMSC需要运行很多连接其它网络(如Internet)的接口，并提供开放的、标准的API接口，支持增值业务的应用与开发。在移动通信网络从第二代向第三代演进的过程中，MMSC可以做到平滑过渡。

　　WAP网关：由于MMS使用WAP作为传输协议，因此需经过WAP网关连接至MMSC。

　　域名服务器（DNS，Domain Name System）／电话号码映射（ENUM，TElephoneNUmber Mapping）：发送方归属的MMSC通过查询DNS／ENUM获得接收方归属MMSC的域名。

　　计费系统：MMSC可作为计费信息采集点，将计费信息传递给计费系统。

　　增值服务系统包括多媒体终端网关、多媒体电子邮件网关、信息传递网关和多媒体语音网关等。

二、MMS运营商之间的互连

　　为了让MMS服务成功地开展起来，不同运营商之间的MMS互连工作就显得十分重要了。从技术观点上看，不同运营商的MMSC之间可以通过运营商之间已有的、稳定可靠的IP网络进行互连(国内运营商之间)或通过公共IP网络、专线（帧中继、ATM）等两种方案。

　　1.直连方案

　　MMS运营商之间通过直连方案实现互连可以采用３种方式：通过在公共ＩＰ网上建立隧道的方式，如采用IPSec技术；通过专线直连的方式，如采用FR和ATM等；通过在专线上构件建VPN的方式。

　　2.GRX（GPRSRoamingExchange）方案

　　首先，介绍一下GRX网络。GRX网络用于连接不同运营商的GPRS骨干网络，以实现GPRS网络间的互联互通。与直连方式不同，GRX网络是一个由第三方公司专业运营与管理的IP网络，负责不同运营商GPRS网络间的互连。由于GRX网络作为GPRS网络互连的核心节点，因此GPRS运营商可以通过与一个或少数几个GRX运营商实现互连，便可在网络层面实现与众多GPRS运营商的互连互通。

　　通过采用GRX网络实现MMS业务国际互通，提供MMS业务的运营商可以避免与所有的互通伙伴建立大量的直接连接，而只需与GRX运营商之间建立少量的连接即可满足互通需求。因此，MMS业务运营商实现互通的关键之一就是选择合适的GRX运营商作为合作伙伴，并根据业务需求采用恰当的方案互连。

　　目前，全球有近20家GRX网络运营商，连接了全球大部分的GPRS网络。2002年2月，芬兰运营商Sonera和爱沙尼亚运营商EMT通过Sonera的GRX网络实现了世界第一个MM（Multimedia Message）的国际互通。2002年6月，芬兰运营商Sonera和中国香港运营商CSL通过Sonera和Aicent的GRX网络实现了亚欧之间第一个MM的国际互通。

　　(注:Sonera既是GPRS运营商，同时又是GRX运营商；Aicent是GRX运营商)

三、MMS的互通业务流程

　　MMS互通的基本业务流程如图1所示。

图1 网络A用户发送多媒体短信至网络B用户的基本流程

　　用户A发送MM消息给用户B。MM消息通过网络A的SGSN（Serving GPRS Support Node）、GGSN（Gateway GPRS Support Node）被传送到网络A的MMSC。

　　网络A的MMSC通过用户B(接收者)的MSISDN 分析出被叫用户为网络B的用户，并要求网络B对用户B进行验证。

　　网络B的HLR回复网络A的MMSC并提供与用户B的MSISDN相对应的IMSI号码。

　　网络A的MMSC通过分析IMSI的MCC和MNC 建立一个前缀为“mms.”的域名地址，此域名地址被发送到与MMSC相连的DNS服务器。

　　网络A的DNS服务器检索网络B的DNS服务器的IP地址。如果未检索到，网络A的DNS服务器将寻址root DNS 服务器去获得网络B的DNS服务器的IP地址。

　　网络B的DNS服务器将本网MMSC的IP地址发送回网络A的DNS服务器。

　　网络A的DNS服务器将网络B的MMSC的IP地址传送到与其相连的MMSC。

　　网络A的MMSC发送MM经由本网的边界网关BG、IP公网（VPN）或GRX、网络B的边界网关BG到网络B的MMSC。

　　通过WAP PUSH功能，网络B的MMSC发送有关收到新消息的通知给用户B（视具体实施情况，SMSC应用在WAP PUSH业务上）。

　　用户B收到包含主题、大小和消息URL的通知后，根据上述消息，终端到MMSC上接收MM消息。

　　图1是个简化图。例如通常BG应包括防火墙和SMTP功能，WAP网关（包括PUSH代理网关）也可以从MMSC中分离出来。

四、MMS互通的相关技术特性和应注意的问题

　　理解MMS互通的技术特点是十分重要与关键的。运营商之间的MMS业务网络互联主要是要求实现MMSC之间的MM4接口，该接口采用基于IP的简单邮件传输协议SMTP（3GPP23.140）。另外，GSMA（Global Systemf or Mobile communication Association）制定了IR.52标准，用于定义MMSC之间的MM4接口，多媒体消息通过该接口在IP网络上从一个MMSC至另一MMSC。到目前为止，已有众多的MMS运营商遵循该标准实现互连。

　　在网络侧，没有必要建设任何种类的独立的只服务于MMS互通的交换网络。在使用公共Internet传输运营商间的MMS之前，有关QoS、安全、互联网络控制、可靠性和对新网络特性的支持已经在GRX网络中得到运用。这是因为事实上GRX可以视为一个为运营商控制的网络，而不像公共Internet那样，对所有人开放。

　　使用Internet作为MM4接口可以在花费上比GRX低些，但同样不是免费的。利用公共Internet作为互联网络也会产生一些问题和花费，例如消息安全规则（比如不可能所有运营商都使用能共同操作的VPN）、地址过滤规则、垃圾消息的控制。MMSC从来不会直接连接到IP互通骨干网上，但所有的MMS消息都必须通过BG网关、防火墙或SMTP网关。

　　应该注意到，如果在MM4接口的两侧中，一侧使用公共Internet（使用VPN或不使用VPN），而同时另一侧使用GRX网络，这时MMS互通会存在一定的问题。这样的连接是很难实施的。例如，为获取被叫MMSC地址而进行的DNS查询是受影响的因素之一，因为GRX和Internet有他们自己的DNS体系。因此，运营商必须协商好MMS互通的技术。比如运营商要大量修改运营商内部IP网络结构的互通网络接口，例如防火墙、代理网关。由于成本和能力的原因，即使根据需求，运营商可以部署多样的网络，我们也建议在互通的MM4接口上使用统一的网络传送消息，以减少相关的选项。如果MMS互通非常成功的话，MMS流量很可能将极大地增加GRX的使用，GRX将不仅仅是个简单的IP骨干网。

　　在业务应用方面，我们也要进行综合考虑。在互通伙伴较多的情况下，GRX方案较直连方案具有优势。使用GRX网络承载MMS业务比直连网络上所有MMSC的工作量小。运营商应该评估MM4接口的物理连接并选择最适当的。考虑到一些商业和业务因素，针对某些去向相对集中的运营商（如MMS接收用户主要集中在为数不多的几个运营商）的时候，专线或IP-VPN网络更加有效。因为IP消息的传送是与上层寻址相分离的，而同时接口会有数条物理连接存在的。

五、结束语

　　我们以上主要讨论了MMS运营商实施互连的网络方案和MMS互通的业务流程，MMS互通业务的开展将给用户带来新的业务享受，同时使不同运营商之间的MM互通成为可能。现在越来越多的运营商已经开始商用MMS互通，尤其是在国际互通方面将是各移动运营商重点发展的业务之一，对于移动运营商而言，其商业前景将具有无可替代的吸引力。

关于语言包的修改.

郭清源 — Mon, 05 Jun 2006 10:30:00 GMT

    现在我们能做的也就是修改下英文的字体了.如果修改输入法中的标点成为中文标点.还有简繁一体包的问题.都需要解密语言包来做.
    改输入法中的标点成为中文标点.还有简繁一体包的问题.都需要解密语言包来做.这些东西任何一个MOTO玩机的都想做的事情.不过对语言包的情况,还知道的不多.我也想过语言包的解密,不过不是一件容易的事情.很难猜出语言包的加密算法.不过我想算法不会太麻烦.
    真的很希望能够解密语言包.主要我的知识还是太少了.我想应该多学点单片机编程和加解密一类的东西,可能有助于这类文件解密吧.

A Checksum Algorithm

郭清源 — Thu, 01 Jun 2006 18:58:00 GMT

A checksum is a value which is computed which allows you to check the validity of something. Typically, checksums are used in data transmission contexts to detect if the data has been transmitted successfully.

Checksums take on various forms, depending upon the nature of the transmission and the needed reliability. For example, the simplest checksum is to sum up all the bytes of a transmission, computing the sum in an 8-bit counter. This value is appended as the last byte of the transmission. The idea is that upon receipt of n bytes, you sum up the first n-1 bytes, and see if the answer is the same as the last byte. Since this is a bit awkward, a variant on this theme is to, on transmission, sum up all the bytes, the (treating the byte as a signed, 8-bit value) negate the checksum byte before transmitting it. This means that the sum of all n bytes should be 0. These techniques are not terribly reliable; for example, if the packet is known to be 64 bits in length, and you receive 64 '\0' bytes, the sum is 0, so the result must be correct. Of course, if there is a hardware failure that simply fails to transmit the data bytes (particularly easy on synchronous transmission, where no "start bit" is involved), then the fact that you receive a packet of 64 0 bytes with a checksum result of 0 is misleading; you think you've received a valid packet and you've received nothing at all. A solution to this is to do something like negate the checksum value computed, subtract 1 from it, and expect that the result of the receiver's checksum of the n bytes is 0xFF (-1, as a signed 8-bit value). This means that the 0-lossage problem goes away.

Nonetheless, for all its simplicity, the checksum technique just described is remarkably weak. For example, if you were to transpose two of the characters of the transmission, the result would be the same, so although the wrong packet is received, a correct checksum is believed. Certain kinds of noise injection on the line can also introduce undetectable errors because the noise that mangles one byte is cancelled by the noise that mangles another byte.

People who care deeply about this have developed a number of much more reliable algorithms. For example, the Cyclic Redundancy Check algorithms, CRC-8, CRC-16, and CRC-32, do fairly complex things to make the checksum sensitive to such problems. For example, using CRC, swapping two bytes in the message will generate a different checksum because the value computed depends not only on the character value, but also on the position in the message in which the byte occurred.

Disk drives often use techniques derived from Hamming Codes (named after Richard Hamming, an AT&T/Bell Laboratories researcher who is probably best known for the techniques he developed for correcting single-bit parity errors in memory, although that is but one of the many applications of his wide-ranging work in mathematical characterizations of data in computer systems). There are some detailed tutorials out there for those of you who wish to pursue this more deeply. Possibly the best-known of these is the set of codes called Fire Codes, named after the inventor, whose surname is Fire (I can't find any citations to him handily, so I can't give you more information than this). These can do things like reconstruct a sequence of bytes (sometimes as many as 20 bytes, on typical disks) that are lost due to burst noise, typically a bad spot on the disk. These are very powerful data recovery codes.

Checksums have many other applications. For example, one feature I find very annoying in many programs is the notion of "change". If I change a value in a dialog, I often get a notification that I have "changed" something, and a save/update/etc. is required. But mostly these are done by detecting if the user (that is, I) have typed anything at all into a control, changed a selection on a ComboBox, etc. A simple Boolean value, maintained by responding to OnChange, OnSelendOK, and similar messages. Of course, if I haven't actually changed the information, or worse still, if I change it back, I get the same warning. I consider such systems primitive beyond recovery, and build systems which are far more user-friendly.

I do this by keeping the information available in some form, most commonly a class. I then compute a checksum on the values when I come in (in OnInitDialog), and recompute it each time there is a change. If the new checksum is the same as the old checksum, I assume that there are no changes. I can then indicate in various ways what is required. In other cases, I'll do this in the CDocument-derived class; whenever a change is effected by the GUI, I recompute the checksum and set the Modified flag according to how the checksum compares to the checksum computed when the document was first created/loaded/whatever, rather than assume any change whatsoever is implicitly a change in content. Thus if the user hits a key in a CEditView then hits the backspace key, I'll end up indicating "no change".

Like most checksum techniques, this decreases in reliability as the number of bytes checksummed increases. This is because the more information you try to pack into a 32-bit value, using an information-losing transformation, the more likely the case where two completely different sequences of values will produce the same 32-bit value. This is one consideration as to why network packets are not sent as megabyte packets; errors in a megabyte transmission might result in the same checksum as the error-free transmission, while for short packet sizes (e.g., 4K, or 1500 bytes) the chances are so low as to not be of any concern in practical networking.

Therefore, my techniques generally are useful when a few thousand bytes of state are involved, such as in a dialog.

I use a technique that has no particular theoretical justification. But I've found it to be reliable for my purposes. The story is that I wanted to use CRC-32 some years ago, but couldn't locate the source code for a CRC-32 algorithm on the Web at that time, so I turned to my Adobe Type 1 Font Handbook and cribbed their encryption algorithm. But rather than encrypt the data, I just used the basic algorithm to create a 32-bit checksum. You can replace my basic algorithm with a 32-bit CRC if you want to. Here's my code, and some commentary on how you might use it.

Checksum.h

class checksum {
public:
    checksum() { clear(); }
    void clear() { sum = 0; r = 55665; c1 = 52845; c2 = 22719;}
    void add(DWORD w);
    void add(BOOL w) { add((DWORD)w); }
    void add(UINT w) { add((DWORD)w); }
    void add(WORD w);
    void add(const CString & s);
    void add(LPBYTE b, UINT length);
    void add(BYTE b);
    DWORD get() { return sum; }
protected:
    WORD r;
    WORD c1;
    WORD c2;
    DWORD sum;
};

Don't worry about those "magic constants" you see r, c1, and c2 being initialized to. They are part of the encryption algorithm, and although I'm sure there is some mystical reason they are set to the particular values shown, many other values (perhaps any other values, except possibly 0 or 1) would suffice.

Note the use of overloading to get various data types. To use the checksum algorithm, create a variable of type checksum, for example, in your desired data structure. You can then call the various add methods to add in the values you wish to checksum (it is rarely the case that doing a checksum of the bytes of the structure yields anything useful; for example, some might represent transient computations that do not affect the actual values of importance; and checksumming the bytes would mean that you checksum the pointers to strings, not the contents of the strings, which leads to the situation where two strings that are otherwise identical would produce different checksums because they were at different addresses. So at some point you determine the structure contains all the values you care about (for example, just after you've read the document, or initialized all the values in OnInitDialog), and you apply the following operations to your checksum variable (which I'll call original). It is convenient to package up the checksum algorithm as shown.

void CMyClass::doChecksum(checksum & chk)
   {
    chk.clear();
    chk.add(flag); // a BOOL
    chk.add(text); // a CString
    chk.add(size); // a DWORD
   }

so you call it as

    doChecksum(original);

Now, at some point, you determine that you have changed something; for example, the user has clicked a checkbox. You capture the Boolean value of the checkbox to the flag variable, then call doChecksum with a new variable, for example, by having the button-clicked, edit-changed, etc. handler call a function computeModification

void CMyClass::computeModification()
   {
    checksum current;
    current.clear();
    doChecksum(current);
    CMyClass::SetModified(current.get() != original.get());
   }

Note that if the checkbox was originally unchecked, and the user checks it, we get an indication (at least in the Modified flag) that the document has changed. If the user then unchecks it, and all other values have been unchanged, we get an indication that the content has not been modified (this means the checksum has to account for all forms of change! And that's your responsibility!)

Checksum.cpp

#include "stdafx.h"

#include "Checksum.h"

/****************************************************************************
*                                  checksum::add
* Inputs:
*        DWORD d: word to add
* Result: void
* 
* Effect: 
*        Adds the bytes of the DWORD to the checksum
****************************************************************************/

void checksum::add(DWORD value)
{
 union { DWORD value; BYTE bytes[4]; } data;
 data.value = value;
 for(UINT i = 0; i < sizeof(data.bytes); i++)
    add(data.bytes[i]);
} // checksum::add(DWORD)

/****************************************************************************
*                                 checksum::add
* Inputs:
*        WORD value:
* Result: void
* 
* Effect: 
*        Adds the bytes of the WORD value to the checksum
****************************************************************************/

void checksum::add(WORD value)
{
 union { WORD value; BYTE bytes[2]; } data;
 data.value = value;
 for(UINT i = 0; i < sizeof(data.bytes); i++)
   add(data.bytes[i]);
} // checksum::add(WORD)

/****************************************************************************
*                                 checksum::add
* Inputs:
*        BYTE value:
* Result: void
* 
* Effect: 
*        Adds the byte to the checksum
****************************************************************************/

void checksum::add(BYTE value)
{
 BYTE cipher = (value ^ (r >> 8));
 r = (cipher + r) * c1 + c2;
 sum += cipher;
} // checksum::add(BYTE)

/****************************************************************************
*                                 checksum::add
* Inputs:
*        const CString & s: String to add
* Result: void
* 
* Effect: 
*        Adds each character of the string to the checksum
****************************************************************************/

void checksum::add(const CString & s)
{
 for(int i = 0; i < s.GetLength(); i++)
    add((BYTE)s.GetAt(i));
} // checksum::add(CString)

/****************************************************************************
*                                 checksum::add
* Inputs:
*        LPBYTE b: pointer to byte array
*        UINT length: count
* Result: void
* 
* Effect: 
*        Adds the bytes to the checksum
****************************************************************************/

void checksum::add(LPBYTE b, UINT length)
{
for(UINT i = 0; i < length; i++)
   add(b[i]);
} // checksum::add(LPBYTE, UINT)

References

Adobe Type 1 Font Format, my hardcopy version is ©1990, Adobe Systems Inc., and is version 1.0. In my edition, the encryption algorithm is shown on page 62. My code is a variant on that algorithm. The hyperlink is to the complete online version of the document (the encryption is on numbered page 62, which is physical page 68 of the .pdf file. The file is 200K in size, is ©1993 and represents version 1.1 of the document).

Tutorials

I have glanced at the tutorials found by a Web search for "Hamming code", and these three references seemed among the best. Some of this is deep stuff. There was a lot more, but these seem representative.

David MacKay has a Web site full of information theory, as does Dr. John A. R. Williams, a page from the RAD company seems informative.

关于MOTO我想说的事.

郭清源 — Wed, 31 May 2006 20:07:00 GMT

我佩服那些MOTOFAN.RU的高手,是因为他们能够彻底研究MOTO手机的东西.
1.从文件格式来说.它们已经掌握了SHX,SMG,手机样式,plmn_text_table.bin,dnp.prf,等一系列文件的格式.从而做出一系列软件来.SHXCODEC,用来分解SHX,并能一定程序上编辑SMG.Language_Editor编辑dnp.prf等等.反观国内对这些东西研究的人微乎其微.所以我希望国内的人能够从应用型转变为研究型的.
2.从手机通信来说.分两种:一种是AT(在MOTO里也有称OBEX),一种是P2K,MPT用的是AT.MEXPLOER可用AT,也可用P2K.p2ktool也是可用AT,可用P2K,用AT可以备份通信录,发送短信等.P2K功能也十分强大.p2k还有一系列软件,就不多说了.其中大部分是RUSSIAN人编的.国产的我想只有一个吧.MOTOKIT.所以我还是比较佩服当初做MOTOKIT的国人的.而且国产的MOTOKIT有其他软件不具备的功能,可扩展性.只要会MOTOKIT的SCRIPT,就可以无限扩大MOTOKIT的功能.
3.刷机就不说了.RANDOM是老大.无人能敌.
4.J2me,J2ME在MOTOFAN.RU也是大放异彩.从HTTP,FTP到TELNET,MAIL系列软件都有.而且界面都非常好.国产的MOTOTXT,其实我不喜欢它.界面不太好.而且我想一个阅读软件做得也太大了.也不精致.国外有一款READMANIC,我特别喜欢就是无法支持中文.而且一些JAVA软件都能在MOTOFAN.RU开专栏.如calc.motofan.ru\ jefan.mtofan.ru

最小的BT软件也是非常优秀的.

郭清源 — Mon, 29 May 2006 11:20:00 GMT

http://www.utorrent.com/
上面是下载网址,软件不到1M,我用的就是这个,大家可以试试.非常不错的软件.最重要的是免费的.

计算机三级过了.

郭清源 — Sun, 28 May 2006 11:25:00 GMT

笔试合格,上机优秀.
比较郁闷.这个只能拿个合格证书.三级网技全是背的.记忆力差就这样了.
不知道该不该报四级了......

JavaOpcode可以在这下

郭清源 — Sun, 28 May 2006 11:22:00 GMT

http://motobbs.com/viewthread.php?tid=19926&extra=page%3D1

看到有人留言要.请到这下吧.
下个Java准备做个计算器.现在最好的计算器是calc.motofan.ru上的一个计算器.不过有太多我不需要的特征.和缺少我需要的功能.不过这个计算器是我认为做得最好的.所以希望自己做个满足自己需要的JAVA计算器.
另外就是改进下已经做出来的两个JAVA了.最近考试比较多.所以没什么时间了.等放了假再做吧.BLOG也暂停更新吧.

Opera一个不错浏览器

郭清源 — Fri, 26 May 2006 17:16:00 GMT

用的是自己的核心,能够支持WML,即能访问手机类的WAP网站.
不过它不支持这个BLOG的富媒体控件,用它在这个BLOG发不了文.不过仍然是个不错的的浏览器