一款复古的搜狗拼音输入法皮肤(DIAN多彩版)，该风格设计者依然是 william ！该皮肤有 白、黑、黄、蓝、绿、紫 多种色调，根据系统的主题色调自行选择使用，复古简约的口味还不错。换换用，养眼。

注意：默认字体是雅黑，若用户的系统没有安装雅黑字体可能会出现不对齐的现象，所以这里我附上雅黑字体供需要的用户下载。

美化对象： 搜狗输入法皮肤
皮肤名称： DIAN 多彩版
文件格式： RAR
文件大小： 320 KB
官方网站： william.w.blogbus.com
文件发布： 雨律在线

免责声明：
　　此文件已经过了JiaJia的正版 卡巴斯基全功能安全软件2009（最新病毒库） 的检测，在JiaJia的爱机上没有出现任何不良反应，但为了用户您的安全，请在下载相关文件后再使用您所信赖的杀毒软件扫描一次。如使用下载的相关文件的过程中对您的爱机造成危害，雨律在线不承担其责任。
　　雨律在线所发表的内容大部分源于互联网，只为学习交流所用，而JiaJia所推荐及建议的内容并不对您的行为构成引导，您应当按照自己需要使用。另外，本站内容为我爱好所写，转载需遵循创造共同协议，即：署名·非商业用途·保持一致。如果雨律在线内容不慎侵犯了您的版权，请及时联系站长JiaJia，站长将尽快处理，撤下相关内容。若JiaJia所写文章中存在错漏之处，希望网友能及时提出及更正，如果喜欢该软件，请购买正版支持作者

下载地址： DIAN皮肤下载 | 雅黑字体下载 2

一款简约的搜狗拼音输入法皮肤(KC2角)，该风格设计者 william 水平很高！该皮肤有白和黑两种色调，根据系统的主题色调自行选择使用，效果是很不错的。我用了搜狗很久很久了，看着默认的皮肤也很久很久了，看到这个皮肤很满意。

注意：默认字体是雅黑，若用户的系统没有安装雅黑字体可能会出现不对齐的现象，所以这里我附上雅黑字体供需要的用户下载。

美化对象： 搜狗输入法皮肤
皮肤名称： KC2
文件格式： RAR
文件大小： 40 KB
官方网站： william.w.blogbus.com
文件发布： 雨律在线

免责声明：
　　此文件已经过了JiaJia的正版 卡巴斯基全功能安全软件2009（最新病毒库） 的检测，在JiaJia的爱机上没有出现任何不良反应，但为了用户您的安全，请在下载相关文件后再使用您所信赖的杀毒软件扫描一次。如使用下载的相关文件的过程中对您的爱机造成危害，雨律在线不承担其责任。
　　雨律在线所发表的内容大部分源于互联网，只为学习交流所用，而JiaJia所推荐及建议的内容并不对您的行为构成引导，您应当按照自己需要使用。另外，本站内容为我爱好所写，转载需遵循创造共同协议，即：署名·非商业用途·保持一致。如果雨律在线内容不慎侵犯了您的版权，请及时联系站长JiaJia，站长将尽快处理，撤下相关内容。若JiaJia所写文章中存在错漏之处，希望网友能及时提出及更正，如果喜欢该软件，请购买正版支持作者

下载地址： KC2皮肤下载 | 雅黑字体下载 2

**************************************************************************************
*
* WarHelper - 加加魔兽助手 [历史保留版本集合]
*
* 版权归 雨律在线 - YuLv.Net - JiaJia 所有
*
* 转载请务必注明来源于 Http://Www.YuLv.Net
*
* 加加唯一指定官方 YuLv.Net 建议用户到官方安全下载
*
**************************************************************************************

　　作为一个已经开发了一年半多的魔兽辅助工具，我可以很负责的告诉大家，我很用心很努力的去做加加魔兽助手。我也可以很肯定的说它是目前市面上最为强大的魔兽争霸III辅助工具，完全符合辅助工具的范畴，没有打查擦边球搞一些歪门邪道。它无论是智能的改键还是智能的显血都是一流的技术水平，更支持对比赛录像的问分析。只要你会用加加魔兽助手你绝对离不开它！
　　也许很多初学者第一次使用觉得设置比较麻烦，但是功能越多越智能的软件是需要一次初始化设置来符合用户的需求的，所谓一劳永逸的道理大家应该都会明白的。

特色：
* 强劲的1键=4键的操作,DOTA卡尔从此更加犀利
* 游戏中改键不影响聊天,无需开关改键再打字
* 切换窗口或切换回桌面,回到游戏照样智能显血条
* 支持鼠标滚轮当键盘用,也就是鼠标改键
* 扩展组合键控制包裹小键盘,空出更多可用改键
* 支持扩大视野的操作,让大屏幕用户更收益,意识翻两番
* 超智能的窗口化处理方案,游戏更快更方便,聊天游戏两不误
* 支持窗口化调整屏幕亮度,不需设置,只需热键操作
* Alt+G点亮小地图的同时刷屏提示队友,解决了漏看小地图的问题
* Alt+0~9快捷键喊话,让魔兽跟网游一样有喊话功能
* 强劲的录像分析功能,分析每场比赛的APM微操水平
* 比赛录像自动保存功能,并且5分钟以下的秒退录像自动忽略

一键操作补充：
* 一键回城 (支持3C、DOTA)
* 一键净化
* 一键丢弃全部包裹物品
* 一键喝血/吃药
* 一键无限烧书/吃书
* 一键技能操作 (可无视是否有没有技能快捷)

注意： 版本不同功能也有所不同，以上介绍的是最新版本中所包涵的功能。

PS: 更多功能不断更新中，网站改版期间请关注加加唯一官方网站[雨律在线 - YuLv.Net]

WarHelper 0.1 最初版

WarHelper 2.7 元宵版

WarHelper 3.1 祝福平安版

WarHelper 3.8 儿童节版

WarHelper 4.0 体验版

WarHelper 4.1 经典版

WarHelper 4.3 彩名版

WarHelper 5.0 修正版

WarHelper 5.1 黄金周版

WarHelper 5.1 正式版

WarHelper 5.3 西安再见版

WarHelper 5.9 捣塔卡尔版

WarHelper 6.0 完整版

WarHelper 6.0 精简版

WarHelper 6.1 绿色优化版

WarHelper 6.2 修正版-精简

WarHelper 6.2 修正版-完整

WarHelper 6.3 一二三版

WarHelper 6.4 糖果版

WarHelper 6.5 加糖版

WarHelper 6.6 劳动版

WarHelper 6.7 完美版

WarHelper 6.8 完美加强版

WarHelper 6.9 完美待续版

WarHelper 7.19 兵器版

总下载地址： 加加魔兽助手历史版本整合下载
转载注明加加官方网站 [雨律在线 - YuLv.Net]

　　在没有工具的环境下怎么实现批量旋转图片？这种问题在网络发达的今天可以在网上搜相关图片处理工具来解决，但是在没有网络的情况下又需要这个功能应该怎么办呢？办法是有的，前提是你使用的系统是 Windows XP 以上的版本。
　　首先打开你将要旋转图片的文件夹，再将查看方式设置为“缩略图”，然后按住[Alt]+鼠标左键批量选择你将要处理的图片，选择完毕之后在任意一张选中的图片上单击鼠标右键，最后根据需要，选择菜单中的“顺时针旋转”或“逆时针旋转”后稍等片刻等待系统处理完成。
　　此方法无需在依靠第三方软件来完成，简单、方便、快速、绿色。 ^_^

 微软为 WinXP，Vista 以及其它程序推出了超过 150 款免费软件，全部找到它们是非常困难的一件事情，下面就是这些免费程序

WINDOWS XP GOODIES

Agent 可以编辑微软帮助中的精灵动画人物所说的话。

Alt-Tab Replacement 使用这个Alt-Tab程序，不仅可看到对应于可供切换应用程序窗口的相关图标，而且，还能对每个窗口页面进行预览 。

Calculator Plus Windows自带计算器的威力加强版。

ConferenceXP 微软的视频会议软件，只是文本聊天和视频聊天，也可以使用电子白板进行讨论以及为别人演示PPT文档。

Feeds Plus IE7的增强Feeds阅读插件

FolderShare 微软的文件同步软件，无论在那里，保证你编辑的文件都是最新的。

GroupBar 一种Windows额外的任务栏，可以对应用程序的窗口进行新的分组，并可以通过快照查看。

Location Finder 微软的一款地图搜索软件，可以使具有WiFi功能的笔记本电脑，台式机，平板电脑，在Windows Live Local上找到你的位置，如果没有WiFi，则可以通过IP地址实现这个功能。

MapCruncher 为微软Virtual Eatrh设计的辅助工具，可以比较简单的发布地图。

My Font Tool 将你手写的字，输出为字体文件。

Open Command Window Here 在右键菜单中增加”Open command Windows Here”，方便你随时随地打开命令窗口(command)

Power Calculator 微软的增强型科学计算机。

Scalable Fabric Windows桌面的高级管理器。

Snip IT 可以在IE浏览器中用邮件发送选中文字的工具

Taskbar Magnifier 从任务栏中放大部分屏幕
TIME ZONES: 有两种方案可以帮助解决多个时区的问题：”高级时区“需要真正的（可能是指正版吧）Windows XP，而”标准时区“不需要

Tweak UI 提供一种途径去搞定系统设定而不暴露在默认的用户界面前，包括鼠标属性的设定，管理器的设定，任务栏的设定等

USB Flash Drive Manager 可以帮助你从闪存中复制、备份以及删除文件，以及一些其他操作。

Virtual Desktop Manager 通过Windows任务栏，可以管理至多4个桌面。

Virtual Machine 使用IE浏览器，通过微软Java Virtual machine，可以在

实例讲解一下可以使用这个软件的场合：你在聊天的同时想看网页的情况，浏览器就在聊天窗口下面，而网页内容太多需要往下翻，这时你就得切换窗口操作。或者等打完字，再切换到浏览器用滚轮操作，真痛苦。那么有了 WizMouse 就不不会痛苦了，边聊天变滚轮看网页不用切换窗口，很爽很适合大屏幕的用户。

这个实力可能太单一，再来个有用的。相信很多读者都是千千静听用户吧？千千静听可以用鼠标滚轮来调整音量，但是对于我等懒虫来说有个“小问题”：必须点击主界面才能用鼠标滚轮来调整音量。用了 WizMouse 之后，只需要把鼠标移动到主界面上，滚动鼠标滚轮。哦也~省去点击了！

不足：
1、Win + R 调用运行之后，必须把鼠标移动到运行窗口上才能用鼠标滚轮来调用以前输入过的历史记录。
2、黑名单和白名单的设置

Ps：关于这些不足 JiaJia 考虑自己写一个这种工具，具体什么时候能弄出来还是未知...

文件名称： WizMouse
文件版本： Beta M6 绿色英文版
文件格式： ZIP / EXE
文件大小： 488 KB
文件发布： 雨律在线

免责声明：
　　此文件已经过了JiaJia的正版 卡巴斯基全功能安全软件2009（最新病毒库） 的检测，在JiaJia的爱机上没有出现任何不良反应，但为了用户您的安全，请在下载相关文件后再使用您所信赖的杀毒软件扫描一次。如使用下载的相关文件的过程中对您的爱机造成危害，雨律在线不承担其责任。
　　雨律在线所发表的内容大部分源于互联网，只为学习交流所用，而JiaJia所推荐及建议的内容并不对您的行为构成引导，您应当按照自己需要使用。另外，本站内容为我爱好所写，转载需遵循创造共同协议，即：署名·非商业用途·保持一致。如果雨律在线内容不慎侵犯了您的版权，请及时联系站长JiaJia，站长将尽快处理，撤下相关内容。若JiaJia所写文章中存在错漏之处，希望网友能及时提出及更正，如果喜欢该软件，请购买正版支持作者

下载地址： WizMouse 下载　　[雨律在线 - YuLv.Net]

JPEG & PNG Stripper 专门用来批量清除照片中不必要的 EXIF 信息，将照片直接拖入 JPEG & PNG Stripper 软件框就完成操作，简单，快捷。

EXIF（Exchangeable image file format）是可交换图像文件的缩写，专门为数码相机的照片设定的，可以记录数码照片的属性信息和拍摄数据。

文件名称： JPEG & PNG Stripper
文件版本： 1.5.0.34 绿色单文件版
文件格式： RAR
文件大小： 80 KB
官方网站： www.steelbytes.com
文件发布： 雨律在线

免责声明：
　　此文件已经过了JiaJia的正版 卡巴斯基全功能安全软件2009（最新病毒库） 的检测，在JiaJia的爱机上没有出现任何不良反应，但为了用户您的安全，请在下载相关文件后再使用您所信赖的杀毒软件扫描一次。如使用下载的相关文件的过程中对您的爱机造成危害，雨律在线不承担其责任。
　　雨律在线所发表的内容大部分源于互联网，只为学习交流所用，而JiaJia所推荐及建议的内容并不对您的行为构成引导，您应当按照自己需要使用。另外，本站内容为我爱好所写，转载需遵循创造共同协议，即：署名·非商业用途·保持一致。如果雨律在线内容不慎侵犯了您的版权，请及时联系站长JiaJia，站长将尽快处理，撤下相关内容。若JiaJia所写文章中存在错漏之处，希望网友能及时提出及更正，如果喜欢该软件，请购买正版支持作者

下载地址： Stripper 下载　　[雨律在线 - YuLv.Net]

/************************************************************************/
/* Zeal 0.11 In-place file splitter
/* By Roger 2008.11.29 http://rogerfd.cn
/* Change log:
/* 2009.2.12 v0.11 fixes a bug when open file with . in dir
/************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <windows.h>
#include <Shlobj.h>

#pragma pack(push, 1)

typedef struct _fat32_boot_sector
{
BYTE u1[11];
WORD bytes_per_sector;
BYTE sectors_per_cluster;
WORD reserved_sectors_count;
BYTE fats_count;
BYTE u2[11];
DWORD hidden_sectors;
DWORD total_sectors_2;
DWORD sectors_per_fat32;
BYTE u3[4];
DWORD rootdir_cluster;
BYTE u4[34];
char type[8];
BYTE u5[420];
WORD end_flag;
}fat32_boot_sector;

typedef struct _dir_item
{
char name[8];
char ext[3];
BYTE attr;
BYTE reserved;
BYTE create_time_ms;
WORD create_time;
WORD create_date;
WORD last_access_time_ms;
WORD first_cluster_high;
WORD last_access_time;
WORD last_access_date;
WORD first_cluster_low;
DWORD size;
}dir_item;

#pragma pack(pop)

#define MAX_BLOCK 127

class zeal
{

public:

zeal ()
{
m_bDebug = false;
m_bOpen = false;
m_arryFatCache = NULL;
};
~zeal ()
{
};
void set_debug (bool debug)
{
m_bDebug = debug;
}
int cut (const char* szFile, unsigned int count);
int restore (const char* szFile);

private:

int open (char vol);
void close ();
DWORD get_fat (DWORD fat_index);
int set_fat (DWORD fat_index, DWORD fat_value);
int create_empty_file (const char* szFile);
int find_item (DWORD dir_cluster, const char* szShortName, OUT DWORD& first_cluster);
int set_item (DWORD dir_cluster, const char* szShortName, DWORD size, DWORD firstcluster);
DWORD get_last_fat (DWORD fat_index);
void msg_debug (const char* msg, ...);
void msg_error (const char* msg, ...);

int m_vol;
bool m_bDebug;
bool m_bOpen;
HANDLE m_hVol;
DWORD m_OffsetFat1;
DWORD m_OffsetFat2;
DWORD m_OffsetCluster0;
DWORD m_OffsetRootdir;
DWORD m_ClusterSize;
PDWORD m_arryFatCache;
fat32_boot_sector m_BootSector;
};

void zeal::msg_debug (const char* msg, ...)
{
if (!m_bDebug)
{
return;
}
va_list arg;
va_start (arg, msg);
vprintf (msg, arg);
va_end (arg);
}

void zeal::msg_error (const char* msg, ...)
{
va_list arg;
va_start (arg, msg);
vprintf (msg, arg);
va_end (arg);
}

int zeal::create_empty_file (const char* szFile)
{
msg_debug ("creating %s ... \n", szFile);
HANDLE h = CreateFile (szFile, 0, 0, 0, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0);
if (h == INVALID_HANDLE_VALUE)
{
return -1;
}
CloseHandle (h);
return 0;
}

void strncpy_no_null (char* to, const char* from, int maxchar)
{
for (int i = 0; i < maxchar; ++i)
{
if (from[i] == 0)
{
break;
}
to [i] = from [i];
}
}

void merge_short_name (const char* name, const char* ext, char* shortname)
{
memset (shortname, ' ', 11);
strncpy_no_null (shortname, name, 8);
strncpy_no_null (shortname + 8, ext+1, 3);
}

DWORD get_file_size (const char* szFile)
{
HANDLE hFile = CreateFile (szFile, 0,
FILE_SHARE_WRITE|FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hFile == INVALID_HANDLE_VALUE)
{
return 0;
}
DWORD dwLSize;
dwLSize = GetFileSize (hFile, NULL);
CloseHandle (hFile);
return dwLSize;
}

DWORD zeal::get_fat (DWORD index)
{
DWORD off = (m_OffsetFat1 + 4*index) & ~0x1FF;
if (!m_bOpen)
{
goto failed;
}

if (index * m_BootSector.sectors_per_cluster + m_OffsetCluster0/512 > m_BootSector.total_sectors_2)
{
msg_error ("get_fat() error: invalid param!\n");
goto failed;
}

if (m_arryFatCache[index] != 1)
{
return m_arryFatCache[index] & 0x0FFFFFFF;
}

if (off != SetFilePointer (m_hVol, off, 0, FILE_BEGIN))
{
msg_error ("SetFilePointer failed!\n");
goto failed;
}

DWORD read, fat;
DWORD buf[128];
if (!ReadFile (m_hVol, (PBYTE)buf, 512, &read, NULL) || read != 512)
{
msg_error ("ReadFile failed!\n");
goto failed;
}
fat = buf [(m_OffsetFat1/4 + index) % 128];
memcpy ((PBYTE)m
_arryFatCache + 4*index - ((m_OffsetFat1 + 4*index) & 0x1FF), buf, 512);
return fat & 0x0FFFFFFF;

failed:
return ~0;
}

DWORD zeal::get_last_fat (DWORD fat_index)
{
DWORD cluster = fat_index;
DWORD next_cluster;
while (TRUE)
{
next_cluster = get_fat (cluster);
if (next_cluster >= 0xFFFFFF8 && next_cluster <=0xFFFFFFF)
{
return cluster;
}
cluster = next_cluster;
}
}

int zeal::set_fat (DWORD fat_index, DWORD fat_value)
{
DWORD off = (m_OffsetFat1 + 4*fat_index) & ~0x1FF;

if (!m_bOpen)
{
goto failed;
}

if (fat_index * m_BootSector.sectors_per_cluster + m_OffsetCluster0/512 > m_BootSector.total_sectors_2)
{
msg_error ("get_fat() error: invalid param!\n");
goto failed;
}

if (off != SetFilePointer (m_hVol, off, 0, FILE_BEGIN))
{
msg_error ("SetFilePointer failed!\n");
goto failed;
}

DWORD read;
DWORD buf[128];
if (!ReadFile (m_hVol, (PBYTE)buf, 512, &read, NULL) || read != 512)
{
msg_error ("ReadFile failed!\n");
goto failed;
}

buf [(m_OffsetFat1/4 + fat_index) % 128] = fat_value;

if (off != SetFilePointer (m_hVol, off, 0, FILE_BEGIN))
{
goto failed;
}

if (!WriteFile (m_hVol, (PBYTE)buf, 512, &read, NULL) || read != 512)
{
msg_error ("WriteFile failed!\n");
goto t>failed;
}

off = (m_OffsetFat2 + 4*fat_index) & ~0x1FF;
if (off != SetFilePointer (m_hVol, off, 0, FILE_BEGIN))
{
msg_error ("SetFilePointer failed!\n");
goto failed;
}

if (!WriteFile (m_hVol, (PBYTE)buf, 512, &read, NULL) || read != 512)
{
msg_error ("WriteFile failed!\n");
goto failed;
}

return 0;

failed:
return -1;
}

int zeal::set_item (DWORD dir_cluster, const char* szShortName, DWORD size, DWORD firstcluster)
{
if (!m_bOpen)
{
return -1;
}

msg_debug ("try to find %s in 0x%x cluster\n", szShortName, dir_cluster);

DWORD cluster = dir_cluster;
LARGE_INTEGER toMove, moved;
PBYTE buf = new BYTE [m_ClusterSize];
for (;;)
{
toMove.QuadPart = cluster * m_ClusterSize + m_OffsetCluster0;
if (!SetFilePointerEx (m_hVol, toMove, &moved, FILE_BEGIN))
{
msg_error ("SetFilePointerEx failed!\n");
goto failed;
}

DWORD read;
if (!ReadFile (m_hVol, buf, m_ClusterSize, &read, NULL) || read != m_ClusterSize)
{
msg_error ("ReadFile failed!\n");
goto failed;
}
dir_item *pItem = (dir_item*) buf;
for (DWORD i = 0; i < m_ClusterSize/32; ++i, ++pItem)
{
msg_debug ("%d name: %0.11s\n", i, pItem->name);
if (pItem->name[0] == 0)
{
msg_error ("file %s not found!\n", szShortName);

goto failed;
}
if (!strnicmp (pItem->name, szShortName, 11))
{
pItem->size = size;
pItem->first_cluster_low = WORD(firstcluster & 0xFFFF);
pItem->first_cluster_high = WORD(firstcluster >> 16);
if (!SetFilePointerEx (m_hVol, toMove, &moved, FILE_BEGIN))
{
msg_error ("SetFilePointerEx failed!\n");
goto failed;
}
DWORD writen;
if (!WriteFile (m_hVol, buf, m_ClusterSize, &writen, NULL) || writen != m_ClusterSize)
{
msg_error ("WriteFile failed!\n");
goto failed;
}
return 0;
}
}

cluster = get_fat (cluster);
if ((0xFFFFFF8 & cluster) == 0xFFFFFF8)
{
msg_error ("file %s not found!\n", szShortName);
goto failed;
}
msg_debug ("try next cluster %X... \n", cluster);
}

failed:
delete[] buf;
return -1;
}

int zeal::find_item (DWORD dir_cluster, const char* szShortName, OUT DWORD& first_cluster)
{
if (!m_bOpen)
{
return -1;
}

msg_debug ("try to find %s in 0x%x cluster\n", szShortName, dir_cluster);
DWORD cluster = dir_cluster;
LARGE_INTEGER toMove, moved;
PBYTE buf = new BYTE [m_ClusterSize];
char name[11];
memset (name, ' ', 11);
strncpy_no_null (name, szShortName, 11);
for (;;)
{
toMove.QuadPart = cluster * m_ClusterSize + m_OffsetCluster0;
if (!SetFilePointerEx (m_hVol, toMove, &moved, FILE_BEGIN))
{
msg_error ("SetFilePointerEx failed!\n");
goto failed;
}

DWORD read;
if (!ReadFile (m_hVol, buf, m_ClusterSize, &read, NULL) || read != m_ClusterSize)
{
msg_error ("ReadFile failed!\n");
goto failed;
}
dir_item *pItem = (dir_item*) buf;
for (DWORD i = 0; i < m_ClusterSize/32; ++i, ++pItem)
{
msg_debug ("%d name: %0.11s\n", i, pItem->name);
if (pItem->name[0] == 0)
{
msg_error ("file %s not found!\n", szShortName);
goto failed;
}
if (!strnicmp (pItem->name, name, 11))
{
first_cluster = (pItem->first_cluster_high << 16) + pItem->first_cluster_low;
msg_debug ("%0.11s found at 0x%x cluster!\n", name, first_cluster);
delete[] buf;
return 0;
}
}
cluster = get_fat (cluster);
if (cluster < 2 || cluster > 0xFFFFFEF)
{
msg_error ("file %s not found!\n", szShortName);
goto failed;
}
}

failed:
delete[] buf;
return -1;
}

int zeal::restore (const char* szFile)
{
char drv[4], shortname[12], path[MAX_PATH], filename[MAX_PATH], ext[MAX_PATH];
char oripath[MAX_PATH] = {0}, shortpath[MAX_PATH], newpath[MAX_PATH];
DWORD count, i, ret;
char *p, *subdir;
DWORD firstclusters[MAX_BLOCK color="#000080">+1], lastclusters[MAX_BLOCK+1];
DWORD cluster = 2, nextcluster, dirCluster, filesize = 0;
DWORD startTime = GetTickCount ();

_splitpath (szFile, drv, path, filename, ext);
if (stricmp (ext, ".zeal"))
{
msg_error ("Not generated by zeal!\n");
goto failed;
}

p = strstr (filename, ".part");
if (!p)
{
msg_error ("Not generated by zeal!\n");
goto failed;
}

if (sscanf (p + 5, "%*d-%d", &count) != 1)
{
msg_error ("Not generated by zeal!\n");
goto failed;
}

memcpy (oripath, szFile, strstr (szFile, ".part") - szFile);
msg_debug ("ori file path: %s\n", oripath);
if (!_access (oripath, 0))
{
msg_error ("%s already exists!\n", oripath);
goto failed;
}

for (i = 1; i <= count; ++i)
{
sprintf (newpath, "%s.part%d-%d.zeal", oripath, i, count);
ret = get_file_size (newpath);
if (ret == 0)
{
msg_error ("%s missing!\n", newpath);
goto failed;
}
filesize += ret;
}

if (open (drv[0]))
{
msg_error ("failed to open %s!\n", drv);
goto failed;
}

// check size a again, to avoid this, make block size align to 64KB
for (i = 1; i < count; ++i)
{
sprintf (newpath, "%s.part%d-%d.zeal", oripath, i, count);
ret = get_file_size (newpath);
r="#0000FF">if (ret & (m_ClusterSize-1))
{
msg_error ("file size alignment error!\n");
goto failed;
}
}

sprintf (newpath, "%s.part%d-%d.zeal", oripath, 1, count);
if(!GetShortPathName(newpath, shortpath, MAX_PATH))
{
msg_error ("GetShortPathName (%s) failed!\n", newpath);
goto failed;
}
_splitpath (shortpath, drv, path, filename, ext);
subdir = strtok (path, "\\");
while (subdir != NULL)
{
_splitpath (subdir, NULL, NULL, filename, ext);
merge_short_name (filename, ext, shortname);
if (find_item (cluster, shortname, nextcluster))
{
msg_error ("find_item failed!\n");
goto failed;
}
cluster = nextcluster;
subdir = strtok (NULL, "\\");
}

dirCluster = cluster;

for (i = 1; i <= count; ++i)
{
sprintf (newpath, "%s.part%d-%d.zeal", oripath, i, count);
if(!GetShortPathName(newpath, shortpath, MAX_PATH))
{
msg_error ("GetShortPathName (%s) failed!\n", newpath);
goto failed;
}

_splitpath (shortpath, drv, path, filename, ext);
merge_short_name (filename, ext, shortname);
if (find_item (dirCluster, shortname, cluster))
{
msg_error ("find_item failed!\n");
goto failed;
}
if (i == 1)
{
if (set_item (dirCluster, shortname, filesize, cluster))
{
msg_error
("set_item failed!\n");
goto failed;
}
}
else
{
if (set_item (dirCluster, shortname, 0, 0))
{
msg_error ("set_item failed!\n");
goto failed;
}
}
firstclusters[i] = cluster;
lastclusters [i] = get_last_fat (cluster);
}

for (i = 1; i < count; ++i)
{
if (set_fat (lastclusters[i], firstclusters[i+1]))
{
msg_error ("set_item failed!\n");
goto failed;
}
}

close ();

for (i = 1; i <= count; ++i)
{
sprintf (newpath, "%s.part%d-%d.zeal", oripath, i, count);
if (i == 1)
{
if (rename (newpath, oripath))
{
msg_error ("rename %s failed!\n", newpath);
goto failed;
}
}
else
{
if (remove (newpath))
{
msg_error ("remove %s failed!\n", newpath);
goto failed;
}
}
}
SHChangeNotify (SHCNE_ALLEVENTS, 0, 0, 0);
printf ("Done! %d ms used\n", GetTickCount () - startTime);
return 0;

failed:

SHChangeNotify (SHCNE_ALLEVENTS, 0, 0, 0);
close ();
return -1;

}

int zeal::cut (const char* szFile, unsigned int count)
{
char drv[4], path[MAX_PATH], filename[MAX_PATH], ext[MAX_PATH];
char shortpath[MAX_PATH], newpath[MAX_PATH];
char shortname[12] = { ont>0};
DWORD nSize, nCluster, nLastCluster, nLastSize, dirCluster, i, j;
DWORD size = get_file_size (szFile);
DWORD firstclusters[MAX_BLOCK+1], lastclusters[MAX_BLOCK+1];
char* subdir;
DWORD cluster = 2, nextcluster;
DWORD startTime = GetTickCount ();
bool files_created = false;

if (count < 2)
{
msg_error ("Nothing to do ?\n");
goto failed;
}

if (count > MAX_BLOCK)
{
msg_error ("Too many blocks! Max %d\n", MAX_BLOCK);
goto failed;
}

if(!GetShortPathName(szFile, shortpath, MAX_PATH))
{
msg_error ("GetShortPathName (%s) failed!\n", szFile);
goto failed;
}

_splitpath (shortpath, drv, path, filename, ext);

// check if files already exists
for (i = 1; i <= count; ++i)
{
sprintf (newpath, "%s.part%d-%d.zeal", szFile, i, count);
if (!_access (newpath, 0))
{
msg_error ("%s already exists!\n", newpath);
goto failed;
}
if (i!=1 && create_empty_file (newpath))
{
msg_error ("Failed to create %s!\n", newpath);
goto failed;
}
}

files_created = true;

if (open (drv[0]))
{
msg_error ("failed to open %s!\n", drv);
goto failed;
}

if (size < m_ClusterSize * count)
{
msg_error ("Block size < %d, exit!\n", m_ClusterSize);
goto failed;
}

// size per block, down align to m_ClusterSize
nSize = (size / count) & ~(m_ClusterSize -
1);
// clusters per block
nCluster = nSize / m_ClusterSize;
// size of last block
nLastSize = size - (count-1)*nSize;
// clusters of last block
nLastCluster = (nLastSize + m_ClusterSize - 1) / m_ClusterSize;

subdir = strtok (path, "\\");
while (subdir != NULL)
{
_splitpath (subdir, NULL, NULL, filename, ext);
merge_short_name (filename, ext, shortname);
if (find_item (cluster, shortname, nextcluster))
{
msg_error ("find_item failed!\n");
goto failed;
}
cluster = nextcluster;
subdir = strtok (NULL, "\\");
}

dirCluster = cluster;

_splitpath (shortpath, drv, path, filename, ext);
merge_short_name (filename, ext, shortname);
if (find_item (dirCluster, shortname, nextcluster))
{
msg_error ("find_item failed!\n");
goto failed;
}

// now nextcluster is the first content of the file
firstclusters[1] = nextcluster;
cluster = nextcluster;
for (i = 2; i <= count; ++i)
{
for (j = 0; j < nCluster; ++j)
{
if (j == nCluster - 1)
{
lastclusters[i-1] = cluster;
}
cluster = get_fat (cluster);
if (cluster < 0x2 || cluster > 0xFFFFFEF)
{
msg_error ("Error parsing fat!\n");
goto failed;
}
}
firstclusters[i] = cluster;
}

// set the others
for (i = 2; i color="#000080">< count; ++i)
{
sprintf (newpath, "%s.part%d-%d.zeal", szFile, i, count);
if(!GetShortPathName(newpath, shortpath, MAX_PATH))
{
printf ("GetShortPathName (%s) failed!\n", newpath);
goto failed;
}
_splitpath (shortpath, drv, path, filename, ext);
merge_short_name (filename, ext, shortname);
if (set_item (dirCluster, shortname, nSize, firstclusters[i]))
{
msg_error ("set_item failed!\n");
goto failed;
}
if (set_fat (lastclusters[i], 0x0FFFFFFF))
{
msg_error ("set_fat failed!\n");
goto failed;
}
}

// set the last one
sprintf (newpath, "%s.part%d-%d.zeal", szFile, i, count);
if(!GetShortPathName(newpath, shortpath, MAX_PATH))
{
msg_error ("GetShortPathName (%s) failed!\n", newpath);
goto failed;
}
_splitpath (shortpath, drv, path, filename, ext);
merge_short_name (filename, ext, shortname);
if (set_item (dirCluster, shortname, nLastSize, firstclusters[count]))
{
msg_error ("set_item failed!\n");
goto failed;
}

// set the first part
if(!GetShortPathName(szFile, shortpath, MAX_PATH))
{
msg_error ("GetShortPathName (%s) failed!\n", newpath);
goto failed;
}
_splitpath (shortpath, drv, path, filename, ext);
merge_short_name (filename, ext, shortname);
if (set_item (dirCluster, shortname, nSize, firstclusters[1]))
{
msg_error (<
/font>"set_item failed!\n");
goto failed;
}
if (set_fat (lastclusters[1], 0x0FFFFFFF))
{
msg_error ("set_fat failed!\n");
goto failed;
}

close ();

sprintf (newpath, "%s.part%d-%d.zeal", szFile, 1, count);
if (rename (szFile, newpath))
{
msg_error ("Rename failed!\n");
goto failed;
}

SHChangeNotify (SHCNE_ALLEVENTS, 0, 0, 0);
printf ("Done! %d ms used\n", GetTickCount () - startTime);
return 0;

failed:

close ();
if (files_created)
{
for (i = 2; i <= count; ++i)
{
sprintf (newpath, "%s.part%d-%d.zeal", szFile, i, count);
remove (newpath);
}
}

return -1;
}

int zeal::open (char vol)
{
if (m_bOpen)
{
close ();
}

char volname[] = "\\\\.\\A:";
volname[4] = vol;
m_hVol = CreateFile (volname,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_FLAG_NO_BUFFERING,
NULL
);

if (m_hVol == INVALID_HANDLE_VALUE)
{
msg_error ("failed to open %s!\n", volname);
goto failed;
}

DWORD ret, read, i;
ret = ReadFile (m_hVol, (PVOID)&m_BootSector, 512, &read, NULL);
if (!ret || read != 512)
{
msg_error ("ReadFile failed!\n");
goto failed;
}

if (strnicmp(m_BootSector.type, "FAT32 ", 8)
||
m_BootSector.end_flag != 0xAA55)
{
msg_error ("Only FAT32 is supported now, NTFS support will come later\n");
goto failed;
}

if (m_BootSector.bytes_per_sector != 512)
{
msg_error ("Error: sector size %d!\n", m_BootSector.bytes_per_sector);
goto failed;
}

m_ClusterSize = 512 * m_BootSector.sectors_per_cluster;
m_OffsetFat1 = m_BootSector.reserved_sectors_count * 512;
m_OffsetFat2 = m_OffsetFat1 + m_BootSector.sectors_per_fat32 * 512;
m_OffsetCluster0 = m_OffsetFat2 + m_BootSector.sectors_per_fat32 * 512 - 2 * m_ClusterSize;
m_OffsetRootdir = m_OffsetCluster0 + m_BootSector.rootdir_cluster * m_ClusterSize;
m_vol = vol;
m_bOpen = true;
m_arryFatCache = new DWORD [m_BootSector.sectors_per_fat32 * 128];
for (i = 0; i < m_BootSector.sectors_per_fat32 * 128; ++i)
{
m_arryFatCache[i] = 1;
}
return 0;

failed:
if (m_hVol != INVALID_HANDLE_VALUE)
{
CloseHandle (m_hVol);
}
return -1;
}

void zeal::close ()
{
if (m_bOpen)
{
CloseHandle (m_hVol);
delete[] m_arryFatCache;
}
m_bOpen = false;
}


void Logo ()
{
puts ("Roger's Zeal for fat32");
puts ("Version: 0.11");
puts ("Mailto : roger99707@163.com");
puts ("Blog : http://rogerfd.cn\n");
}

void Usage ()
{
puts ("Zeal is a in-place file spiltter ");
puts ("Usage: zeal.exe file_to_split(full path) count ");
puts (" zeal.exe file_to_restore(any piece) ");
}


int main (int argc, char* argv[])
{
Logo ();
zeal z;
if (argc < 2 <
/font>|| argc > 3)
{
Usage ();
return 0;
}
#ifdef _DEBUG
z.set_debug (true);
#else
z.set_debug (false);
#endif
if (argc == 3)
{
z.cut (argv[1], atoi(argv[2]));
}
if (argc == 2)
{
z.restore (argv[1]);
}
return 0;
}