/* WebDownloader for X-Window
* Copyright (C) 1999-2002 Koshelev Maxim
* This Program is free but not GPL!!! You can't modify it
* without agreement with author. You can't distribute modified
* program but you can distribute unmodified program.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <ctype.h>
#include <unistd.h>
#include <time.h>
#include <glib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pwd.h>
#include "var.h"
#include "dbc.h"
/* char *copy_string();
return the same string allocated in new area;
*/
char *copy_string2(const char *src,int len) {
if (src==NULL) return NULL;
char *temp=new char[len+1];
if (temp){
strncpy(temp,src,len);
temp[len]=0;
};
return temp;
};
char *copy_string(const char *src) {
if (src==NULL) return NULL;
return copy_string2(src,strlen(src));
};
/* int equal(const char, const char)
params: two strings
return: zero if a!=b and nonzero if a==b
*/
int equal(const char *a,const char *b) {
if (!a) {
if (b) return 0;
return 1;
};
if (!b) return 0;
while (*a==*b && *a!=0) {
a++;
b++;
};
if (*b==*a) return 1;
return 0;
};
/* the same as previos one but case insensetive
*/
int equal_uncase(const char *a,const char *b) {
if (!a) {
if (b) return 0;
return 1;
};
if (!b) return 0;
if (strcasecmp(a,b)) return 0;
return 1;
};
/* int equal_first()
params: two strings
return: non zero if first string is begining of second one
else return value is zero;
*/
int equal_first(const char *a,const char *b) {
DBC_RETVAL_IF_FAIL(a!=NULL,0);
DBC_RETVAL_IF_FAIL(b!=NULL,0);
int la=strlen(a);
int lb=strlen(b);
if (la==0 || lb==0) return 0;
int min=la<lb?la:lb;
return !strncmp(a,b,min);
};
int equal_first_uncase(const char *a,const char *b) {
DBC_RETVAL_IF_FAIL(a!=NULL,0);
DBC_RETVAL_IF_FAIL(b!=NULL,0);
int la=strlen(a);
int lb=strlen(b);
if (la==0 || lb==0) return 0;
int min=la<lb?la:lb;
return !strncasecmp(a,b,min);
};
/* int begin_string()
params: char *str, char *begin
return: zero if `begin' is not begining of `str'
non zero if `begin' is begining of `str'
*/
int begin_string(const char *str,const char *begin) {
DBC_RETVAL_IF_FAIL(str!=NULL,0);
DBC_RETVAL_IF_FAIL(begin!=NULL,0);
if (equal_first(str,begin) && strlen(str)>=strlen(begin)) return 1;
return 0;
};
int begin_string_uncase(const char *str,const char *begin) {
DBC_RETVAL_IF_FAIL(str!=NULL,0);
DBC_RETVAL_IF_FAIL(begin!=NULL,0);
if (equal_first_uncase(str,begin) && strlen(str)>=strlen(begin)) return 1;
return 0;
};
/* char *sum_strings()
params: list if strings ended by NULL;
return: cotatenated string
*/
char *sum_strings(const char *a,...){
DBC_RETVAL_IF_FAIL(a!=NULL,NULL);
va_list args;
int l=strlen(a)+1;
va_start(args,a);
char *s=va_arg(args, char*);
while(s){
l+=strlen(s);
s=va_arg(args, char*);
};
char *r=new char[l];
if (r){
*r=0;
strcat(r,a);
va_start(args,a);
s=va_arg(args, char*);
while(s){
strcat(r,s);
s=va_arg(args, char*);
};
};
return r;
};
char *compose_strings_array(int *len,const char *a,int la,const char *b){
DBC_RETVAL_IF_FAIL(a!=NULL,NULL);
int lb=(b?strlen(b)+1:0);
char *r=new char[la+lb];
memcpy(r,a,la);
if (b)
memcpy(r+la,b,lb);
*len=la+lb;
return r;
};
// next function reallocate memory for string and return new size
int reallocate_string(char **what, int len){
int newlen=len+MAX_LEN+1;
char *temp=new char[newlen];
strncpy(temp,*what,len);
temp[len+1]=0;
delete *what;
*what=temp;
return newlen;
};
/* int empty_string();
params: string
return: non zero if string contains only spaces
zero if not only spaces
*/
int empty_string(char *a) {
DBC_RETVAL_IF_FAIL(a!=NULL,0);
int len=strlen(a);
for (int i=0;i<len;i++,a++) {
if (!isspace(*a))
return 0;
};
return 1;
};
/* str_replace();
params: string, string to search, string to put on the place of second string
return: new allocated string
action: replace all occurrences of the second parameter in the first paramter by the third parameter
*/
char *str_replace(const char *str,const char *where,const char *what){
char *a=NULL;
int len1=strlen(where);
int len2=strlen(what);
int len3=strlen(str);
char *rval=copy_string(str);
char *cur=rval;
while ((a=strstr(cur,where))){
int len=len3-len1+len2;
char *old=rval;
rval=new char[len+1];
int l=a-old;
memcpy(rval,old,l);
memcpy(rval+l,what,len2);
cur=rval+l+len2;
memcpy(rval+l+len2,a+len1,len3-l-len1);
len3+=len2-len1;
rval[len3]=0;
delete[]old;
};
return rval;
};
/* convert_int_to_2()
params: integer and pointer to buffer
return: none
action: convert integer to hexademal pair of chars
*/
template <typename Integral>
inline std::string format_int_xx(Integral what) {
if (what>=10)
return boost::lexical_cast<std::string>(what);
return std::string("0")+boost::lexical_cast<std::string>(what);
};
/* convert_time();
params: number of seconds, pointer to buffer
return: none
action: convert number of seconds to nice string HH:MM:SS
*/
std::string convert_time(int what,int TIME_FORMAT) {
int hours = what/int(3600);
int mins = (what%3600)/int(60);
if (!TIME_FORMAT) {
int secs = what%60;
return format_int_xx(hours)+":"+format_int_xx(mins)+":"+format_int_xx(secs);
};
return format_int_xx(hours)+":"+format_int_xx(mins);
};
/* string_to_low();
params: string;
return: none;
action: convert string to low case;
*/
void string_to_low(char *what) {
DBC_RETURN_IF_FAIL(what!=NULL);
while (*what) {
if (*what>='A' && *what<='Z')
*what+='a'-'A';
what+=1;
};
};
/* the same as previos but till delimeter caracter
*/
void string_to_low(char *what,char delim) {
DBC_RETURN_IF_FAIL(what!=NULL);
char *temp=index(what,delim);
while (*what && what!=temp) {
if (*what>='A' && *what<='Z')
*what+='a'-'A';
what+=1;
};
};
char *index_mult(char *str,const char *what){
DBC_RETVAL_IF_FAIL(str!=NULL,NULL);
DBC_RETVAL_IF_FAIL(what!=NULL,NULL);
while (*str){
char *a=index(what,*str);
if (a) return(str);
str++;
};
return(NULL);
};
/* convert_from_hex()
params: char
return: integer equal to value in hexademal notation
of specifyed character
*/
int convert_from_hex(unsigned char what) {
if (what>='0' && what<='9')
return(what-'0');
if (what>='a' && what<='f')
return (10+what-'a');
if (what>='A' && what<='F')
return (10+what-'A');
return -1;
};
int convert_from_hex(char what) {
if (what>='0' && what<='9')
return(int(what)-'0');
if (what>='a' && what<='f')
return (10+int(what)-'a');
if (what>='A' && what<='F')
return (10+int(what)-'A');
return -1;
};
int convert_from_hex(char a,char b) {
int aa=convert_from_hex(a);
int bb=convert_from_hex(b);
if (aa<0 || bb<0) return 1000;
return (aa<<4)|bb;
};
/* convert_to_hex();
params: char, pointer to buffer
return: none
action: coverts character to hexademal string (e.g. ' ' -> "20")
*/
static const char _dec_to_hex_[16]={
'0','1','2','3','4','5','6','7','8','9',
'A','B','C','D','E','F'
};
void convert_to_hex(unsigned char what,char *where) {
DBC_RETURN_IF_FAIL(where!=NULL);
*where = _dec_to_hex_[what/16];
where[1] = _dec_to_hex_[what%16];
};
void convert_to_hex_s(char what,char *where) {
unsigned char b=*((unsigned char*)&what);
convert_to_hex(b,where);
};
/* parse_percents();
params: string
return: new allocated string in which all %xx codes from input string
are replaced.
*/
char *parse_percents(char *what) {
DBC_RETVAL_IF_FAIL(what!=NULL,NULL);
/* Next string is too ugly because I use "new" in separate threads;
*/
char *temp=new char[strlen(what)+1];
if (temp==NULL) return(NULL);
char *where=temp,*old=what;
while (*old) {
switch (*old){
case '%':{
int num=convert_from_hex(old[1]);
if (num>=0 && old[2]) {
int num1=convert_from_hex(old[2]);
if (num1>=0){
num=num *16 + num1;
*where=char(num);
old+=2;
break;
};
};
};
default:{
*where=*old;
};
};
where+=1;
old+=1;
};
*where=0;
return temp;
};
/* unparse_percents();
params: string;
return: allocated string in which special simbols from input are
replaced by %xx;
*/
char *unparse_percents(char *what) {
DBC_RETVAL_IF_FAIL(what!=NULL,NULL);
const char *true_chars=".-+%";
const char *false_chars=":<>~ ";
char *temp=what;
int unparsed_len=0;
while (*temp){
if ((*temp<'/' || *temp>'z' || index(false_chars,*temp)!=NULL) && index(true_chars,*temp)==NULL)
unparsed_len+=3;
else
unparsed_len+=1;
temp+=1;
};
char *rvalue=new char[unparsed_len+1];
if (rvalue){
char *cur=rvalue;
temp=what;
while (*temp){
if ((*temp<'/' || *temp>'z'|| index(false_chars,*temp)!=NULL) && index(true_chars,*temp)==NULL){
*cur='%';
cur+=1;
convert_to_hex(*temp,cur);
cur+=1;
}else
*cur=*temp;
cur+=1;
temp+=1;
};
*cur=0;
};
return rvalue;
};
static const char *_url_true_chars_=".-+&";
static const char *_url_false_chars_=":<>~% ";
#include <iostream>
std::string hexed_string(const std::string &str){
std::string rval(str);
std::string::size_type len=rval.length(),pos=0;
char buf[4]={'%',0,0,0};
while(pos<len){
char r=rval[pos];
if ((r<'/' || r>'z' || index(_url_false_chars_,r))
&& index(_url_true_chars_,r)==0){
convert_to_hex_s(r,buf+1);
rval.replace(pos,1,buf);
pos+=2;
len+=2;
};
pos++;
};
return rval;
};
std::string unhexed_string(const std::string &str){
std::string::size_type pos=0;
std::string::size_type len=str.length();
std::string rval(str);
while((pos=rval.find('%',pos))!=std::string::npos){
if (len<pos+1) break;
if (len>=pos+2){
int b=convert_from_hex(rval[pos+1],rval[pos+2]);
if (b<256){
char buf[2]={b,0};
rval.replace(pos,3,buf);
len-=2;
};
};
pos++;
};
return rval;
};
/* escape_char();
params: string, char to search, escaped character;
return: string
action: allocate new string with char `what' escaped
by char `bywhat'
*/
char *escape_char(const char *where,char what,char bywhat){
DBC_RETVAL_IF_FAIL(where!=NULL,NULL);
int num=0;
char *tmp=index(where,what);
while(tmp){
num+=1;
tmp=index(tmp+1,what);
};
if (num){
char *rvalue=new char[strlen(where)+num*2+1];
*rvalue=0;
char *r=rvalue;
tmp=index(where,what);
while(tmp){
if (tmp-where)
memcpy(r,where,tmp-where);
r+=tmp-where;
r[0]=bywhat;
r[1]=what;
r+=2;
where=tmp+1;
tmp=index(where,what);
};
*r=0;
if (*where)
memcpy(r,where,strlen(where)+1);
return rvalue;
};
return(copy_string(where));
};
/* str_non_print_replace();
params: string, char
return: none
action: replace all character<' ' in string `what' by `symbol'
*/
void str_non_print_replace(char *what,char symbol){
DBC_RETURN_IF_FAIL(what!=NULL);
unsigned char *temp=(unsigned char *)what;
while (*temp){
if (*temp<' ') *temp=(unsigned char )symbol;
temp+=1;
};
while (temp > (unsigned char *)what){
temp--;
if (*temp==' ') *temp=0;
else break;
};
};
/* del_crlf()
params: string
return: none
action: cut string to '\n' or '\r'
*/
void del_crlf(char *what) {
DBC_RETURN_IF_FAIL(what!=NULL);
char *tmp;
while((tmp=rindex(what,'\n')) || (tmp=rindex(what,'\r'))) {
*tmp=0;
};
};
/* is_string()
params: string
return: non zero if there are not only digits in string
zero if there are only digits in string
*/
int is_string(char *what){
DBC_RETVAL_IF_FAIL(what!=NULL,0);
char *current=what;
while (*current){
if (*current<'0' || *current>'9') return 1;
current+=1;
};
return 0;
};
/*
* This function extract string from string with spaces
* for example:
* given the string ' aa blala'
* extracted value will be 'aa'
*/
char *my_space_locate(char *what){
DBC_RETVAL_IF_FAIL(what!=NULL,NULL);
char *tmp=what;
while (*tmp){
if (isspace(*tmp)) return(tmp);
tmp+=1;
};
return NULL;
};
char *extract_string(char *src,char *dst) {
DBC_RETVAL_IF_FAIL(src!=NULL,NULL);
DBC_RETVAL_IF_FAIL(dst!=NULL,NULL);
char *tmp=src;
while (*tmp && isspace(*tmp)) tmp++;
char *space=my_space_locate(tmp);
while (*tmp && tmp!=space) {
*dst=*tmp;
dst++;
tmp++;
};
*dst=0;
return tmp;
};
char *extract_string(char *src,char *dst,int num){
DBC_RETVAL_IF_FAIL(src!=NULL,NULL);
DBC_RETVAL_IF_FAIL(dst!=NULL,NULL);
char *new_src=src;
for (int i=0;i<num;i++){
new_src=extract_string(new_src,dst);
};
return(new_src);
};
char *extract_from_prefixed_string(char *str,char *begin){
DBC_RETVAL_IF_FAIL(str!=NULL,NULL);
DBC_RETVAL_IF_FAIL(begin!=NULL,NULL);
char *tmp=str+strlen(begin);
while (isspace(*tmp)) tmp+=1;
char *rvalue=copy_string(tmp);
return rvalue;
};
/* skip_spaces();
params: poiter to char
return: pointer to first non space char
*/
char *skip_spaces(char *src){
DBC_RETVAL_IF_FAIL(src!=NULL,NULL);
char *tmp=src;
while(*tmp && isspace(*tmp))
tmp+=1;
return tmp;
};
/* skip_strings()
params: pointer to char, number of substring to skip
return: pointer to char after last skipped string;
*/
char *skip_strings(char *src,int num){
DBC_RETVAL_IF_FAIL(src!=NULL,NULL);
char *tmp=src;
for (int i=0;i<num;i++) {
char *tmp1=my_space_locate(tmp);
if (tmp1) while (isspace(*tmp1)) tmp1++;
else break;
tmp=tmp1;
};
return tmp;
};
/* convert_month()
params: pointer to char
return: number of month beging from 0;
*/
int convert_month(char *src) {
DBC_RETVAL_IF_FAIL(src!=NULL,0);
switch(*src) {
case 'j':
case 'J':{
if (src[1]=='a' || src[1]=='A') return 0;
if (src[2]=='n' || src[2]=='N') return 5;
return 6;
};
case 'a':
case 'A':{
if (src[1]=='u' || src[1]=='U') return 7;
return 3;
};
case 'm':
case 'M':{
if (src[2]=='r' || src[2]=='R') return 2;
return 4;
};
case 'f':
case 'F':
return 1;
case 's':
case 'S':
return 8;
case 'o':
case 'O':
return 9;
case 'n':
case 'N':
return 10;
case 'd':
case 'D':
return 11;
};
return 0;
};
/* ctime_to_time();
params: string
return: time
action: convert string in ctime() format to time_t
*/
int ctime_to_time(char *src) {
DBC_RETVAL_IF_FAIL(src!=NULL,0);
char data[MAX_LEN];
char *tmp=extract_string(src,data);
time_t NOW=time(NULL);
struct tm date;
localtime_r(&NOW,&date);
date.tm_isdst=-1;
if (tmp && *tmp) {
tmp=extract_string(tmp,data);
sscanf(data,"%i",&date.tm_mday);
};
if (tmp && *tmp) {
tmp=extract_string(tmp,data);
date.tm_mon=convert_month(data);
};
if (tmp && *tmp) {
tmp=extract_string(tmp,data);
sscanf(data,"%i",&date.tm_year);
date.tm_year-=1900;
};
if (tmp && *tmp) {
extract_string(tmp,data);
if (index(data,':')) {
char *tmpdata=data;
sscanf_int(tmpdata,&(date.tm_hour));
tmpdata+=3;
sscanf_int(tmpdata,&(date.tm_min));
tmpdata+=3;
sscanf_int(tmpdata,&(date.tm_sec));
};
};
#ifdef HAVE_STRUCT_TM_TM_ZONE
return(mktime(&date)+date.tm_gmtoff);
#else
return(mktime(&date));
#endif
};
/* check_mask();
params: string, mask
return: non zero if `src' is satisfied by `mask'
zero if `src' is not satisfied by `mask'
*/
int check_mask(const char *src,const char *mask) {
DBC_RETVAL_IF_FAIL(mask!=NULL,0);
DBC_RETVAL_IF_FAIL(src!=NULL,0);
const char *m=mask;
const char *s=src;
while (*m) {
if (*m=='*') {
if (*s==0) return 0;
m+=1;
s+=1;
while (*s) {
if (check_mask(s,m)) return 1;
s+=1;
};
} else {
if (*s!=*m) return 0;
s+=1;
m+=1;
};
};
return (!*s);
};
/* int check_mask2(char *,char *)
almost the same as check_mask() but
allow ? as any symbol
*/
int check_mask2(const char *src,const char *mask) {
DBC_RETVAL_IF_FAIL(mask!=NULL,0);
DBC_RETVAL_IF_FAIL(src!=NULL,0);
const char *m=mask;
const char *s=src;
while (*m) {
switch(*m){
case '*':{
if (*s==0) return 0;
s+=1;m+=1;
while (*s) {
if (check_mask2(s,m)) return 1;
s+=1;
};
break;
};
case '?':
if (*s==0) return 0;
s+=1;m+=1;
break;
default:
if (*s!=*m) return 0;
s+=1;m+=1;
};
};
return (!*s);
};
/* int check_mask2_uncase(char *,char *)
case insensetive variant of check_mask2()
*/
int check_mask2_uncase(const char *src,const char *mask) {
DBC_RETVAL_IF_FAIL(mask!=NULL,0);
DBC_RETVAL_IF_FAIL(src!=NULL,0);
const char *m=mask;
const char *s=src;
while (*m) {
switch(*m){
case '*':{
if (*s==0) return 0;
s+=1;m+=1;
while (*s) {
if (check_mask2_uncase(s,m)) return 1;
s+=1;
};
break;
};
case '?':
if (*s==0) return 0;
s+=1;m+=1;
break;
default:
if (tolower(*s)!=tolower(*m)) return 0;
s+=1;m+=1;
};
};
return (!*s);
};
void normalize_path(char *src) {
DBC_RETURN_IF_FAIL(src!=NULL);
char *a=src,*b=src;
while (*a) {
if (*a=='/'){
int need_exit=0;
do {
switch(a[1]){
case '/':
a+=1;
break;
case '.':{
if (a[2]=='/' || a[2]==0){
a+=2;
break;
};
if (a[2]=='.' && (a[3]=='/' || a[3]==0)){
if (b>src) b-=1;
while (b>src && *b!='/') b-=1;
a+=3;
break;
};
};
default:
need_exit=1;
};
if (*a==0) break;
}while(!need_exit);
};
if ((*b=*a)==0) return;
b+=1;
a+=1;
};
*b=0;
};
char *normalize_path_full(char *src){
DBC_RETVAL_IF_FAIL(src!=NULL,NULL);
if (*src=='~'){
struct passwd *p;
char *cur=index(src,'/');
if (src[1]=='/'){
p=getpwuid(getuid());
}else{
if (cur) *cur=0;
p=getpwnam(src+1);
if (cur) *cur='/';
};
if (p){
char *path=sum_strings(p->pw_dir,cur,NULL);
normalize_path(path);
return(path);
};
};
char *rval=copy_string(src);
normalize_path(rval);
return(rval);
};
/* FIXME: compose_path() should be rewritten!!!
*/
char *compose_path(const char *left,const char *right){
DBC_RETVAL_IF_FAIL(left!=NULL,NULL);
DBC_RETVAL_IF_FAIL(right!=NULL,NULL);
char *newpath=sum_strings(left,"/",right,NULL);
normalize_path(newpath);
return(newpath);
};
/*
char *compose_path(const char *left,const char *right) {
DBC_RETVAL_IF_FAIL(left!=NULL,NULL);
DBC_RETVAL_IF_FAIL(right!=NULL,NULL);
char *newpath=NULL;
int len=strlen(left);
if (*right!='/' && (len==0 || left[len-1]!='/'))
newpath=sum_strings(left,"/",right, NULL);
else
newpath=sum_strings(left,right, NULL);
len=strlen("/../");
char *up=strstr(newpath,"/../");
while (up){
while (up>newpath && *(up-1)=='/') up-=1;
*up=0;
char *tmp=rindex(newpath,'/');
*up='/';
if (tmp){
while (tmp>newpath && *(tmp-1)=='/') tmp-=1;
memmove(tmp+1,up+len,strlen(up+len)+1);
}else{
memmove(newpath,up+len-1,strlen(up+len)+2);
};
up=strstr(newpath,"/../");
};
if (!string_ended("/..",newpath)){
char *tmp=newpath+strlen(newpath)-3;
while (tmp>newpath && *(tmp-1)=='/') tmp-=1;
*tmp=0;
tmp=rindex(newpath,'/');
if (tmp){
*tmp=0;
}else{
*newpath=0;
};
};
// printf("%s + %s -> %s\n",left,right,newpath);
return(newpath);
};
*/
/*
char *compose_path(const char *left,const char *right) {
DBC_RETVAL_IF_FAIL(left!=NULL,NULL);
DBC_RETVAL_IF_FAIL(right!=NULL,NULL);
unsigned int ll=strlen(left);
unsigned int rl=strlen(right);
char *updir="../";
char *thisdir="./";
if (begin_string(right,updir) || equal(right,"..")) {
char *tmp=rindex(left,'/');
if (ll && left[ll-1]=='/'){
char *tmp2=tmp;
*tmp2=0;
tmp=rindex(left,'/');
*tmp2='/';
};
if (tmp) {
*tmp=0;
int dl=rl>strlen("..")?strlen(updir):strlen("..");
char *tmp2=compose_path(left,right+dl);
*tmp='/';
return tmp2;
};
};
if (begin_string(right,thisdir))
return compose_path(left,right+strlen(thisdir));
if (ll && left[ll-1]!='/' && rl && *right!='/')
return(sum_strings(left,"/",right,NULL));
return(sum_strings(left,right,NULL));
};
*/
char *subtract_path(const char *a,const char *b){
DBC_RETVAL_IF_FAIL(a!=NULL,NULL);
DBC_RETVAL_IF_FAIL(b!=NULL,NULL);
int i=0;
char *temp=index(b,'/');
while (temp){
while (*temp=='/') temp+=1;
temp=index(temp,'/');
i+=1;
};
i-=1;
temp=rindex(a,'/');
while (temp && i>0){
*temp=0;
char *tmp=rindex(a,'/');
*temp='/';
temp=tmp;
i-=1;
if (i==0){
tmp=copy_string(a);
return tmp;
};
};
return copy_string("/");
};
void scroll_string_left(char *str,unsigned int shift){
DBC_RETURN_IF_FAIL(str!=NULL);
unsigned int len=strlen(str);
if (len<=shift || shift==0) return;
char *temp=new char[len+1];
if (temp==NULL) return; // can't allocate memory
temp[len]=0;
for (unsigned int i=0;i<len;i++){
unsigned int realshift=shift+i>=len?shift+i-len:shift+i;
temp[i]=str[realshift];
};
for (unsigned int i=0;i<len;i++)
str[i]=temp[i];
delete[] temp;
};
//void scroll_string_right();
int get_permisions_from_int(int a){
int rvalue=0;
int a1=a/(int)100;
int a2=(a-a1*100)/(int)10;
int a3=(a-a1*100-a2*10);
rvalue=(a1*64)+(a2*8)+(a3);
// printf("%i:%i,%i,%i:%i(%i)\n",a,a1,a2,a3,rvalue,S_IRUSR|S_IWUSR);
return rvalue;
};
/*this function will return 0 if 'what' was
ended by 'edned', less than 0 if 'what' less than 'ended'
or greater than 0 if vice versa
*/
int string_ended(const char *ended, const char *what){
if (ended==NULL || what==NULL) return 0;
int a=strlen(ended);
int b=strlen(what);
int min=a<b?a:b;
char *aa=(char *)(ended+a-min);
char *bb=(char *)(what+b-min);
return strncmp(aa,bb,min);
};
int string_ended_uncase(const char *ended, const char *what){
if (ended==NULL || what==NULL) return 0;
int a=strlen(ended);
int b=strlen(what);
int min=a<b?a:b;
char *aa=(char *)(ended+a-min);
char *bb=(char *)(what+b-min);
return strncasecmp(aa,bb,min);
};
std::string filename_extension(const std::string &name){
std::string::size_type pos=name.rfind('.');
if (pos!=std::string::npos){
return name.substr(pos+1);
};
return std::string();
};
/* primitive file operations
*/
int f_wchar(int fd,char c){
return(write(fd,&c,sizeof(char)));
};
int f_wstr(int fd,const char *str){
DBC_RETVAL_IF_FAIL(str!=NULL,0);
return(write(fd,str,strlen(str)));
};
int f_wstr_lf(int fd,const char *str){
DBC_RETVAL_IF_FAIL(str!=NULL,0);
int a=f_wstr(fd,str);
if (a<0) return a;
int b=f_wstr(fd,"\n");
if (b<0) return b;
return(a+b);
};
int f_rstr(int fd,char *where,int max) {
DBC_RETVAL_IF_FAIL(where!=NULL,0);
char *cur=where;
max-=1;
if (max>0){
int i=max;
while(read(fd,cur,1)>0 && i>0) {
i-=1;
if (*cur=='\n') break;
cur+=1;
};
*cur=0;
return max-i;
};
*where=0;
return 0;
};
int write_named_string(int fd,const char *name,const char *str){
if (name==NULL || str==NULL) return(0);
if (f_wstr_lf(fd,name)<0) return(-1);
if (f_wstr_lf(fd,str)<0) return(-1);
return 0;
};
int write_named_integer(int fd,const char *name,int num){
if (name==NULL) return(0);
if (f_wstr_lf(fd,name)<0) return(-1);
char str[MAX_LEN];
g_snprintf(str,MAX_LEN,"%d",num);
if (f_wstr_lf(fd,str)<0) return(-1);
return 0;
};
int write_named_time(int fd,const char *name,time_t when){
if (name==NULL) return(0);
if (f_wstr_lf(fd,name)<0) return(-1);
char str[MAX_LEN];
g_snprintf(str,MAX_LEN,"%ld",(long int)(when));
if (f_wstr_lf(fd,str)<0) return(-1);
return 0;
};
int write_named_fsize(int fd,const char *name,fsize_t size){
if (name==NULL) return(0);
if (f_wstr_lf(fd,name)<0) return(-1);
char str[MAX_LEN];
g_snprintf(str,MAX_LEN,"%lli",size);
if (f_wstr_lf(fd,str)<0) return(-1);
return 0;
};
/* length of string with specified integer;
*/
int int_to_strin_len(int num){
int len=num<0?2:1;
num/=10;
while (num){
num/=10;
len+=1;
};
return len;
};
/* scanf for int begined from zero */
int sscanf_int(char *str,int *where){
DBC_RETVAL_IF_FAIL(str!=NULL,0);
DBC_RETVAL_IF_FAIL(where!=NULL,0);
if (str==NULL) return 0;
while (*str=='0' && str[1]!='0')
str+=1;
return(sscanf(str,"%i",where));
};
/* covert path from /lalala/lalala/%[D]_%[M] to
/lalala/lalala/12_02 where 12 is current day
02 is current month
*/
enum DATE_FMTS_ENUM{
DFMT_DAY,
DFMT_MONTH,
DFMT_YEAR,
DFMT_HOURS,
DFMT_MINS,
DFMT_SECS,
DFMT_TIME,
DFMT_DATE,
DFMT_EXT,
DFMT_NONE
};
static char* date_fmts[]={
"[D]", //day
"[M]", //month
"[Y]", //year
"[h]", //hours
"[m]", //minutes
"[s]", //seconds
"[T]", // time in format HH:MM
"[DATE]", // date in format DD_MM_YEAR
"[E]" // extension of a file in upper case
};
char *get_extension(const char *name){
if (name==NULL) return(NULL);
const char *a=name+strlen(name)-1;
while(a>=name){
if (*a=='.'){
a+=1;
if (*a==0) return(NULL);
char *rval=copy_string(a);
string_to_low(rval);
return(rval);
};
if (*a=='/') return(NULL);
a-=1;
};
return(NULL);
};
char *parse_save_path(const char *str,const char *file){
DBC_RETVAL_IF_FAIL(str!=NULL,NULL);
int len=0;
char *rval;
char *ext=get_extension(file);
int extlen=0;
const char *a=str;
time_t tmptime=time(NULL);
struct tm *tmp_tm=new tm;
localtime_r(&tmptime,tmp_tm);
tmp_tm->tm_year+=1900;
tmp_tm->tm_mon+=1;
/* calc length of returned string */
while (*a){
if (*a=='%'){
unsigned int i;
for (i=0;i<sizeof(date_fmts)/sizeof(char*);i++){
if (equal_first(date_fmts[i],a+1))
break;
};
switch(i){
case DFMT_EXT:
if (ext){
extlen=strlen(ext);
len+=extlen;
};
a+=strlen(date_fmts[i]);
break;
case DFMT_DAY:
case DFMT_MONTH:
case DFMT_HOURS:
case DFMT_MINS:
case DFMT_SECS:
len+=2;
a+=strlen(date_fmts[i]);
break;
case DFMT_TIME:
len+=5;
a+=strlen(date_fmts[i]);
break;
case DFMT_DATE:
len+=6+int_to_strin_len(tmp_tm->tm_year);
a+=strlen(date_fmts[i]);
break;
case DFMT_YEAR:
len+=int_to_strin_len(tmp_tm->tm_year);
a+=strlen(date_fmts[i]);
break;
default:
len+=1;
break;
};
}else{
len+=1;
};
a+=1;
};
rval=new char[len+1];
char *b=rval;
a=str;
#define FMT_TMP_NEXT b+=2;a+=strlen(date_fmts[i]);break
while (*a){
if (*a=='%'){
unsigned int i;
for (i=0;i<sizeof(date_fmts)/sizeof(char*);i++){
if (equal_first(date_fmts[i],a+1))
break;
};
switch(i){
case DFMT_EXT:
if (ext){
memcpy(b,ext,extlen);
b+=extlen;
};
a+=strlen(date_fmts[i]);
break;
case DFMT_DAY:
sprintf(b,"%02i",tmp_tm->tm_mday);
FMT_TMP_NEXT;
case DFMT_MONTH:
sprintf(b,"%02i",tmp_tm->tm_mon);
FMT_TMP_NEXT;
case DFMT_HOURS:
sprintf(b,"%02i",tmp_tm->tm_hour);
FMT_TMP_NEXT;
case DFMT_MINS:
sprintf(b,"%02i",tmp_tm->tm_min);
FMT_TMP_NEXT;
case DFMT_SECS:
sprintf(b,"%02i",tmp_tm->tm_sec);
FMT_TMP_NEXT;
case DFMT_TIME:
sprintf(b,"%02i:%02i",
tmp_tm->tm_hour,tmp_tm->tm_min);
b+=5;
a+=strlen(date_fmts[i]);
break;
case DFMT_DATE:
sprintf(b,"%02i_%02i_%i",
tmp_tm->tm_mday,tmp_tm->tm_mon,
tmp_tm->tm_year);
b+=6+int_to_strin_len(tmp_tm->tm_year);
a+=strlen(date_fmts[i]);
break;
case DFMT_YEAR:
sprintf(b,"%i",tmp_tm->tm_year);
b+=int_to_strin_len(tmp_tm->tm_year);
a+=strlen(date_fmts[i]);
break;
default:
*b=*a;
b+=1;
break;
};
}else{
*b=*a;
b+=1;
};
a+=1;
};
delete(tmp_tm);
if (ext) delete[] ext;
*b=0;
return(rval);
};
/* tPStr
Protected String
*/
tPStr::tPStr(){
a=NULL;
};
tPStr::tPStr(const char*s){
a=copy_string(s);
};
bool tPStr::notempty(){
return(a!=NULL && a[0]!=0);
};
void tPStr::set(const char *b){
if (a) delete[] a;
a=copy_string(b);
};
tPStr::~tPStr(){
if (a)
delete[] a;
};
/***************************************************************/
void make_proxy_host(const char *host,int port){
char *tmp=new char[strlen(host)+10];
char *b=tmp;
while(*host!=':' && *host){
*b=*host;
host++;
b++;
};
*b=':';
b++;
sprintf(b,"%i",port);
if (*tmp!=':' && *tmp)
ALL_HISTORIES[PROXY_HISTORY]->add(tmp);
delete[] tmp;
};
int file_copy(char *from,char *to,char *buf,int size){
FILE *src=fopen(from,"r");
if (src==NULL){
return(-1);
};
FILE *dst=fopen(to,"w+");
if (dst==NULL){
fclose(src);
return(-1);
};
int len=0;
int rval=0;
while ((len=fread(buf,1,size,src))>0){
if (fwrite(buf,len,1,dst)!=1){
rval=-1;
break;
};
};
fclose(dst);
fclose(src);
return(rval);
};
syntax highlighted by Code2HTML, v. 0.9.1