source: tags/initial/ORS_COM/ORS_lib.cxx

Last change on this file was 2, checked in by oldcode, 23 years ago

Initial revision
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.5 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <memory.h>
4#include <malloc.h>
5#include <string.h>
6#include <arbdb.h>
7#include <time.h>
8#include <stdarg.h>
9#include <ctype.h>
10#include <crypt.h>
11
12#include <ors_client.h>
13#include <client.h>
14#include <servercntrl.h>
15#include <ors_lib.h>
16
17
18/*****************************************************************************
19  CRYPT A PASSWORD
20                                                        return strdup
21*****************************************************************************/
22char *ORS_crypt(char *password) {
23        static char *crypted_pw1 = 0;
24        delete crypted_pw1;
25        static char *crypted_pw2 = 0;
26        delete crypted_pw2;
27
28        char *use_pw = password;
29
30        static char *salt="XX";
31
32        if (!password) use_pw="";
33
34        sprintf(salt,"%2i",strlen(use_pw));
35
36        char *temp = crypt(use_pw, salt);       // crypt first part
37        crypted_pw1 = strdup(temp + 2);
38
39        if (strlen(password) <= 8)      use_pw="";
40        else                            use_pw = password + 8;
41
42        temp = crypt(use_pw, salt);             // crypt second part
43        crypted_pw2 = strdup(temp + 2);
44
45        char *result=(char *)calloc(sizeof(char),strlen(crypted_pw1) + strlen(crypted_pw2) + 1);
46        strcpy(result, crypted_pw1);
47        strcpy(result + 8, crypted_pw2);
48        return result;
49}
50
51/*****************************************************************************
52  Contruct Error Message
53*****************************************************************************/
54char *ORS_export_error(char *templat, ...)
55        {
56        char buffer[10000];
57        char *p = buffer;
58        va_list parg;
59        // sprintf (buffer,"ORS ERROR: ");
60        p += strlen(p);
61        va_start(parg,templat); 
62
63        vsprintf(p,templat,parg);
64
65        return strdup(buffer);
66}
67
68/*****************************************************************************
69  Contruct String
70*****************************************************************************/
71char *ORS_sprintf(char *templat, ...)
72        {
73        char buffer[10000];
74        char *p = buffer;
75        va_list parg;
76        p += strlen(p);
77        va_start(parg,templat); 
78
79        vsprintf(p,templat,parg);
80
81        return strdup(buffer);
82}
83
84
85/*******************************************************************************
86        Time & Date Strings
87                                type determines output format
88                                time = desired time/date value or 0     
89********************************************************************************/
90char *ORS_time_and_date_string(int type, long time) {
91        long current_time;
92
93        if (!time) current_time = GB_time_of_day();
94        else current_time = time;
95        struct tm *tms = localtime(&current_time);
96        static char buffer[256];
97
98        switch(type) {
99                case TIME_HM:   strftime( buffer, 255, "%H:%M", tms); break;
100                case DATE_DMY:  strftime( buffer, 255, "%d.%m.%Y", tms); break;
101                case DATE_TIME: strftime( buffer, 255, "%d.%m.%Y - %H:%M", tms); break;
102                default: buffer[0] = 0;
103        }
104        return buffer;
105}
106
107/*************************************************************
108  return number of occurences of a seek character within str
109**************************************************************/
110int ORS_str_char_count(char *str, char seek) {
111        int count;
112        char *pos;
113
114        if (!str) return 0;
115
116        for (count = 0, pos = strchr(str,seek); pos; pos=strchr(pos+1,seek)) count++;
117        return count;
118}
119
120/***********************************************************
121  string case compare of str1 and str2 with length of str2
122************************************************************/
123int ORS_strncmp(char *str1, char *str2)
124{
125        if (!str2) return 1;
126        return strncmp(str1,str2,strlen(str2));
127}
128
129/******************************************************
130  compare str2 with the tail of str1 (length of str2)
131*******************************************************/
132int ORS_strncase_tail_cmp(char *str1, char *str2) {
133       
134        if (!str1 || !str2) return 1;
135
136        return strncasecmp(str1 + strlen(str1) - strlen(str2), str2, strlen(str2));
137}
138
139/******************************************************
140  trim: removes leading & trailing spaces and tabs
141*******************************************************/
142char *ORS_trim(char *str) {
143        if (!str) return 0;
144        while (*str) {
145                if (*str == '\t' || *str == ' ') str++;
146                else break;
147        }
148        if (!*str) return str;
149        char *end=str + strlen(str) - 1;
150        while (end > str) {
151                if (*end == '\t' || *end == ' ' || *end == '\n') {
152                        *end=0;
153                        end--;
154                }
155                else break;
156        }
157        return str;
158}
159
160/******************************************************
161  contains: contains a token (with seperator)
162                                returns true or false
163*******************************************************/
164int ORS_contains_word(char *buffer, char *word, char seperator) {
165        char    *pos = buffer;
166        int     len;
167       
168        if (!word || !buffer) return 0;
169
170        len = strlen(word);
171        while (pos) {
172                pos = strstr(pos, word);
173                if (!pos) break;
174                if ( (pos == buffer || *(pos-1) == seperator) && (*(pos+len) == seperator || *(pos+len) == 0 ) ) 
175                        return 1;  // found it!
176                pos++;
177        }
178        return 0;
179}
180
181/******************************************************
182  SEQ MATCHES TARGET: validate normalized sequences
183                                returns true or false
184*******************************************************/
185int ORS_seq_matches_target_seq(char *seq, char *target, int complemented) {
186        char *spos = seq;
187        char *tpos = target;
188
189        if (!seq || !target) return 0;
190        if (!*seq || !*target) return 0;
191        if (strlen(seq) != strlen(target)) return 0;
192
193        if (complemented) tpos = target + strlen(seq) - 1;
194
195        while (*spos && *tpos) {
196                switch(*spos) {
197                        case 'A': if (*tpos == 'T' || *tpos == 'U'); break;
198                        case 'C': if (*tpos == 'G'); break;
199                        case 'G': if (*tpos == 'C'); break;
200                        case 'T': if (*tpos == 'A'); break;
201                        case 'U': if (*tpos == 'A'); break;
202
203                        case 'M': if (*tpos == 'K'); break;
204                        case 'K': if (*tpos == 'M'); break;
205                        case 'R': if (*tpos == 'Y'); break;
206                        case 'Y': if (*tpos == 'R'); break;
207                        case 'S': if (*tpos == 'S'); break;
208                        case 'V': if (*tpos == 'B'); break;
209                        case 'B': if (*tpos == 'V'); break;
210                        case 'D': if (*tpos == 'H'); break;
211                        case 'H': if (*tpos == 'D'); break;
212                        case 'X': if (*tpos == 'X'); break;
213                        case 'N': if (*tpos == 'X'); break;
214                        case '.': if (*tpos == '.'); break;
215                        default: return 0;
216                }
217                spos++;
218                if (complemented) tpos--;
219                             else tpos++;
220        }
221        return 1;
222}
223
224/******************************************************
225  CALC 4GC 2AT
226                                returns strdup()
227*******************************************************/
228char * ORS_calculate_4gc_2at(char *sequence) {
229        static char buffer[10];
230
231        int gc=0, at=0;
232
233        if (!sequence || !*sequence) return strdup("");
234        char *pos = sequence;
235        while (*pos) {
236                switch(*pos) {
237                        case 'G': gc++; break;
238                        case 'C': gc++; break;
239                        case 'A': at++; break;
240                        case 'T': at++; break;
241                        case 'U': at++; break;
242                        default: break;
243                }
244                pos++;
245
246        }
247        sprintf(buffer, "%i C", 4*gc + 2*at);
248        return strdup(buffer);
249}
250
251/******************************************************
252  CALC GC RATIO
253                                returns strdup()
254*******************************************************/
255char * ORS_calculate_gc_ratio(char *sequence) {
256        static char buffer[10];
257
258        double min=0, max=0;
259
260        if (!sequence || !*sequence) return strdup("");
261
262        // calculate minimum
263        char *pos = sequence;
264        while (*pos) {
265                switch(*pos) {
266                        case 'G': 
267                        case 'C': 
268                        case 'S': min++; break;
269                        default: break;
270                }
271                pos++;
272
273        }
274
275        // calculate maximum
276        pos = sequence;
277        while (*pos) {
278                switch(*pos) {
279                        case 'G': 
280                        case 'C': 
281                        case 'M': 
282                        case 'R': 
283                        case 'S': 
284                        case 'Y': 
285                        case 'K': 
286                        case 'V': 
287                        case 'H': 
288                        case 'D': 
289                        case 'B': 
290                        case 'X': 
291                        case 'N': max++; break;
292                        default: break;
293                }
294                pos++;
295
296        }
297        if (min == max) sprintf(buffer, "%1g %%", min / (double) strlen(sequence) * 100);
298        else            sprintf(buffer, "%4.1f %% - %4.1f %%", min / (double) strlen(sequence) * 100, max / (double) strlen(sequence) * 100);
299        return strdup(buffer);
300}
301
302/******************************************************
303  STRCMP: can compare NULL-pointers!
304        NULL == NULL
305        NULL == ""
306                                returns true or false
307*******************************************************/
308ORS_strcmp(char *str1, char *str2) {
309        if (!str1 && !str2) return 0;
310        if ((str1 && *str1 && !str2) || (!str1 && str2 && *str2)) return 1;
311        if ((!str1 && !*str2) || (!*str1 && !str2) || (!*str1 && !*str2)) return 0;
312        return strcmp(str1, str2);
313}
314
315/*****************************************************************************
316  FIND NEXT char IN A LIST
317                                must be initialized with start=buffer, end=0
318                returns 1 when found, otherwise 0 and changes start, end
319*****************************************************************************/
320int OC_find_next_chr(char **start, char **end, char chr) {
321        int first_time=0;
322
323        if (*start != *end && *end != 0) {
324                if (**end == 0) *start = *end;
325                else            *start = *end + 1;
326        } else if (*start == *end) {
327                (*start)++;     // last field was empty
328        }
329
330        if (!start || !*start) return 0;
331        *end = strchr(*start,chr);
332        if (*start == *end && **end != 0) {     // empty field found
333                return 1;
334        }
335        if (!*end) {
336                *end = strchr(*start,0);
337                if (*start == *end) return 0;   // last time was last field
338                // *start = *end;
339                return 1;       // last field
340        }
341        return 1;       // first or middle field
342}
343
344/*******************************************************
345  IS PARENT OF: check whether user1 is father of user2
346                        return 1 if true, 0 else
347********************************************************/
348int ORS_is_parent_of(char *user1, char *user2) {
349
350        if (!user1 || !*user1 || !user2 || !*user2) return 0;
351       
352        if (!strcmp(user1,ROOT_USERPATH)) return 1; // root ist everybody's father
353        int len1=strlen(user1);
354        if ( !strncmp(user1,user2,len1) && user2[len1] == '/') return 1;        // user1 is begin of user2 and user2 continues -> ok
355        return 0;
356}
357
358/*******************************************************
359  IS PARENT OR EQUAL: check whether user1 is father of user2; user1 = user2 is true
360                        return 1 if true, 0 else
361********************************************************/
362int ORS_is_parent_or_equal(char *user1, char *user2) {
363
364        if (!user1 || !user2) return 0;
365        if (!strcmp(user1, user2)) return 1;
366        return ORS_is_parent_of(user1, user2);
367}
368
369/*******************************************************
370  GET PARENT OF: calculate parent of userpath
371                                return strdup or NULL
372********************************************************/
373char * ORS_get_parent_of(char *userpath) {
374
375        if (!strcmp(userpath,"/")) return 0;            // root has no father
376        char *pos=strrchr(userpath,'/');
377        if (!pos) return 0;                             // no slash means: no father
378        if (pos == userpath) return strdup("/");        // only one slash: root is father
379        *pos=0;
380        static char *u=0;
381        delete u;
382        u=strdup(userpath);
383        *pos='/';
384        return u;
385}
386
387/*******************************************************
388  STR 2 UPPER: converse string to upper case
389                                return strdup or NULL
390********************************************************/
391char * ORS_str_to_upper(char *str1) {
392        if (!str1 || !*str1) return strdup("");
393
394        char *str2 = (char *)calloc(sizeof(char), strlen(str1) + 1);
395        char *pos=str2;
396        while (*pos) {
397                *pos=toupper(*pos);
398        }
399        return str2;
400}
Note: See TracBrowser for help on using the repository browser.