LeafOK_CVS/innwebd/BBS_fun.cpp

/*******************************************************/
/*                                                     */
/*  LeafOK Innbbsd                                     */
/*                                                     */
/*  Copyright (C) LeafOK.com, 2003-2008                */
/*                                                     */
/*  http://www.leafok.com                              */
/*                                                     */
/*******************************************************/

#include "StdAfx.h"
#include ".\bbs_fun.h"
#include "atlenc.h"

BBS_fun::BBS_fun(void)
{
}

BBS_fun::~BBS_fun(void)
{
}

CString BBS_fun::LML(const CString& source_str)
{
        bool lml;
        CString result_str,tag_str,tag_arg,tag_result;
        int pre,p_current,l_source,p_start,p_end,p_space,p_tag_end;

        lml=true;
        result_str="";
        pre=0;
        p_current=0;
        l_source=(int)strlen(source_str);

        while (p_current < l_source)
        {
                p_start=source_str.Find('[',p_current);
                if (p_start != -1)
                {
                        p_space=source_str.Find(' ',p_start+1);
                        p_end=source_str.Find(']',p_start+1);
                        if (p_end == -1)
                                p_end=l_source-1;
                        if ((p_space != -1) && (p_space < p_end))
                        {
                                p_tag_end=p_space;
                                if (p_end-p_tag_end>0)
                                {
                                        tag_arg=source_str.Mid(p_tag_end+1,p_end-p_tag_end-1);
                                        tag_arg.Trim();
                                }
                                else
                                        tag_arg="";
                        }
                        else
                        {
                                tag_arg="";
                                p_tag_end=p_end;
                        }
                        if (p_tag_end-p_start>0)
                        {
                                tag_str=source_str.Mid(p_start+1,p_tag_end-p_start-1);
                                tag_str.Trim();
                                tag_str.MakeLower();
                        }
                        else
                                tag_str="";
                        if (lml == true)
                        {
                                //Code for switch == true was omitted
                                tag_result="";
                                if (tag_str == "nolml")
                                {
                                        lml=false;
                                }
                                if (tag_str == "left")
                                {
                                        tag_result="[";
                                }
                                if (tag_str == "right")
                                {
                                        tag_result="]";
                                }
                                if (tag_str == "image")
                                {
                                        tag_result=tag_arg;
                                }
                                if (tag_str == "bwf")
                                {
                                        tag_result="****";
                                }
                        }
                        else
                        {
                                tag_result=source_str.Mid(p_start,p_end-p_start+1);
                                if (tag_str == "lml")
                                {
                                        lml=true;
                                        tag_result="";
                                }
                        }
                        if (p_start-p_current>0)
                                result_str = result_str + source_str.Mid(p_current,p_start-p_current);
                        result_str += tag_result;
                        p_current=p_end+1;
                }
                else
                {
                        if (l_source > p_current)
                        {
                                result_str += source_str.Mid(p_current);
                        }
                        p_current=l_source;
                }
        }

        return result_str;
}

CString BBS_fun::ip_mask(const CString& ip, int level)
{
        int dot_pos;

        switch(level)
        {
                case 0:
                        return ip;
                case 1:
                        dot_pos=ip.Find('.');
                        if (dot_pos == -1)
                                return CString();
                        return (ip.Left(dot_pos+1) + "*");
                case 2:
                        dot_pos=ip.Find('.');
                        if (dot_pos == -1)
                                return CString();
                        dot_pos=ip.Find('.',dot_pos+1);
                        if (dot_pos == -1)
                                return CString();
                        return (ip.Left(dot_pos+1) + "*.*");
        }
        return ip;
}

CString BBS_fun::FB2TXT(CString source_str)
{
        CString result_str = "";
        int i,j,len;

        len = CString::StringLength(source_str);
        result_str = "";

        for (i=0;i<len;i++)
        {
                if (source_str[i]=='\033')
                {
                        for (j=i+1;j<len;j++)
                        {
                                if (source_str[j]=='m')
                                {
                                        j++;
                                        break;
                                }
                        }
                        i=j-1;
                }
                else
                {
                        result_str.AppendChar(source_str[i]);
                }
        }
                
        return result_str;
}

CString BBS_fun::GB_decode(const CString& source_str)
{
        CString search_str,result_str;
        int pos,pos_f,len,len_b_str,len_decode;
        char p_buf_s[65536],p_buf_d[65536];
        bool found;

        search_str = source_str;
        search_str.MakeUpper();
        result_str = "";
        pos = 0;
        len = CString::StringLength(source_str);
        len_b_str = CString::StringLength("=?gb2312?Q?");

        while(pos<len)
        {
                found = false;

                //QPDecode
                if ((pos_f = search_str.Find("=?GB2312?Q?",pos))>=0)
                {
                        found = true;
                        result_str += source_str.Mid(pos,pos_f-pos);
                        pos = pos_f + len_b_str;
                        if ((pos_f = source_str.Find("?=",pos))>=0)
                        {
                                strcpy(p_buf_s,source_str.Mid(pos,pos_f-pos));
                                pos = pos_f + 2;
                        }
                        else
                        {
                                strcpy(p_buf_s,source_str.Mid(pos));
                                pos = len;
                        }
                        len_decode = 65536;
                        if (QPDecode((BYTE *)p_buf_s,(int)strlen(p_buf_s),p_buf_d,&len_decode))
                        {
                                p_buf_d[len_decode]='\0';
                                result_str += p_buf_d;
                        }
                        else
                        {
                                result_str += p_buf_s;
                        }
                }

                //Base64Decode
                if ((pos_f = search_str.Find("=?GB2312?B?",pos))>=0)
                {
                        found = true;
                        result_str += source_str.Mid(pos,pos_f-pos);
                        pos = pos_f + len_b_str;
                        if ((pos_f = source_str.Find("=?=",pos))>=0)
                        {
                                strcpy(p_buf_s,source_str.Mid(pos,pos_f-pos));
                                pos = pos_f + 3;
                        }
                        else
                        {
                                strcpy(p_buf_s,source_str.Mid(pos));
                                pos = len;
                        }
                        len_decode = 65536;
                        if (Base64Decode(p_buf_s,(int)strlen(p_buf_s),(BYTE *)p_buf_d,&len_decode))
                        {
                                p_buf_d[len_decode]='\0';
                                result_str += p_buf_d;
                        }
                        else
                        {
                                result_str += p_buf_s;
                        }
                }

                if (!found)
                {
                        result_str += source_str.Mid(pos);
                        pos = len;
                }
        }

        return result_str;
}
1	/*******************************************************/
2	/* */
3	/* LeafOK Innbbsd */
4	/* */
5	/* Copyright (C) LeafOK.com, 2003-2008 */
6	/* */
7	/* http://www.leafok.com */
8	/* */
9	/*******************************************************/
10
11	#include "StdAfx.h"
12	#include ".\bbs_fun.h"
13	#include "atlenc.h"
14
15	BBS_fun::BBS_fun(void)
16	{
17	}
18
19	BBS_fun::~BBS_fun(void)
20	{
21	}
22
23	CString BBS_fun::LML(const CString& source_str)
24	{
25	bool lml;
26	CString result_str,tag_str,tag_arg,tag_result;
27	int pre,p_current,l_source,p_start,p_end,p_space,p_tag_end;
28
29	lml=true;
30	result_str="";
31	pre=0;
32	p_current=0;
33	l_source=(int)strlen(source_str);
34
35	while (p_current < l_source)
36	{
37	p_start=source_str.Find('[',p_current);
38	if (p_start != -1)
39	{
40	p_space=source_str.Find(' ',p_start+1);
41	p_end=source_str.Find(']',p_start+1);
42	if (p_end == -1)
43	p_end=l_source-1;
44	if ((p_space != -1) && (p_space < p_end))
45	{
46	p_tag_end=p_space;
47	if (p_end-p_tag_end>0)
48	{
49	tag_arg=source_str.Mid(p_tag_end+1,p_end-p_tag_end-1);
50	tag_arg.Trim();
51	}
52	else
53	tag_arg="";
54	}
55	else
56	{
57	tag_arg="";
58	p_tag_end=p_end;
59	}
60	if (p_tag_end-p_start>0)
61	{
62	tag_str=source_str.Mid(p_start+1,p_tag_end-p_start-1);
63	tag_str.Trim();
64	tag_str.MakeLower();
65	}
66	else
67	tag_str="";
68	if (lml == true)
69	{
70	//Code for switch == true was omitted
71	tag_result="";
72	if (tag_str == "nolml")
73	{
74	lml=false;
75	}
76	if (tag_str == "left")
77	{
78	tag_result="[";
79	}
80	if (tag_str == "right")
81	{
82	tag_result="]";
83	}
84	if (tag_str == "image")
85	{
86	tag_result=tag_arg;
87	}
88	if (tag_str == "bwf")
89	{
90	tag_result="****";
91	}
92	}
93	else
94	{
95	tag_result=source_str.Mid(p_start,p_end-p_start+1);
96	if (tag_str == "lml")
97	{
98	lml=true;
99	tag_result="";
100	}
101	}
102	if (p_start-p_current>0)
103	result_str = result_str + source_str.Mid(p_current,p_start-p_current);
104	result_str += tag_result;
105	p_current=p_end+1;
106	}
107	else
108	{
109	if (l_source > p_current)
110	{
111	result_str += source_str.Mid(p_current);
112	}
113	p_current=l_source;
114	}
115	}
116
117	return result_str;
118	}
119
120	CString BBS_fun::ip_mask(const CString& ip, int level)
121	{
122	int dot_pos;
123
124	switch(level)
125	{
126	case 0:
127	return ip;
128	case 1:
129	dot_pos=ip.Find('.');
130	if (dot_pos == -1)
131	return CString();
132	return (ip.Left(dot_pos+1) + "*");
133	case 2:
134	dot_pos=ip.Find('.');
135	if (dot_pos == -1)
136	return CString();
137	dot_pos=ip.Find('.',dot_pos+1);
138	if (dot_pos == -1)
139	return CString();
140	return (ip.Left(dot_pos+1) + ".");
141	}
142	return ip;
143	}
144
145	CString BBS_fun::FB2TXT(CString source_str)
146	{
147	CString result_str = "";
148	int i,j,len;
149
150	len = CString::StringLength(source_str);
151	result_str = "";
152
153	for (i=0;i<len;i++)
154	{
155	if (source_str[i]=='\033')
156	{
157	for (j=i+1;j<len;j++)
158	{
159	if (source_str[j]=='m')
160	{
161	j++;
162	break;
163	}
164	}
165	i=j-1;
166	}
167	else
168	{
169	result_str.AppendChar(source_str[i]);
170	}
171	}
172
173	return result_str;
174	}
175
176	CString BBS_fun::GB_decode(const CString& source_str)
177	{
178	CString search_str,result_str;
179	int pos,pos_f,len,len_b_str,len_decode;
180	char p_buf_s[65536],p_buf_d[65536];
181	bool found;
182
183	search_str = source_str;
184	search_str.MakeUpper();
185	result_str = "";
186	pos = 0;
187	len = CString::StringLength(source_str);
188	len_b_str = CString::StringLength("=?gb2312?Q?");
189
190	while(pos<len)
191	{
192	found = false;
193
194	//QPDecode
195	if ((pos_f = search_str.Find("=?GB2312?Q?",pos))>=0)
196	{
197	found = true;
198	result_str += source_str.Mid(pos,pos_f-pos);
199	pos = pos_f + len_b_str;
200	if ((pos_f = source_str.Find("?=",pos))>=0)
201	{
202	strcpy(p_buf_s,source_str.Mid(pos,pos_f-pos));
203	pos = pos_f + 2;
204	}
205	else
206	{
207	strcpy(p_buf_s,source_str.Mid(pos));
208	pos = len;
209	}
210	len_decode = 65536;
211	if (QPDecode((BYTE *)p_buf_s,(int)strlen(p_buf_s),p_buf_d,&len_decode))
212	{
213	p_buf_d[len_decode]='\0';
214	result_str += p_buf_d;
215	}
216	else
217	{
218	result_str += p_buf_s;
219	}
220	}
221
222	//Base64Decode
223	if ((pos_f = search_str.Find("=?GB2312?B?",pos))>=0)
224	{
225	found = true;
226	result_str += source_str.Mid(pos,pos_f-pos);
227	pos = pos_f + len_b_str;
228	if ((pos_f = source_str.Find("=?=",pos))>=0)
229	{
230	strcpy(p_buf_s,source_str.Mid(pos,pos_f-pos));
231	pos = pos_f + 3;
232	}
233	else
234	{
235	strcpy(p_buf_s,source_str.Mid(pos));
236	pos = len;
237	}
238	len_decode = 65536;
239	if (Base64Decode(p_buf_s,(int)strlen(p_buf_s),(BYTE *)p_buf_d,&len_decode))
240	{
241	p_buf_d[len_decode]='\0';
242	result_str += p_buf_d;
243	}
244	else
245	{
246	result_str += p_buf_s;
247	}
248	}
249
250	if (!found)
251	{
252	result_str += source_str.Mid(pos);
253	pos = len;
254	}
255	}
256
257	return result_str;
258	}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1