Mercurial > ~mikael > mcabber > hg
annotate mcabber/mcabber/utils.c @ 2225:dc3b3ac1ba76
Free the buffdata structures when buffers are closed
Free the buffdata strcutures when buffers are closed and there are no
more users (these structures can be shared if the "symlink" shared history
is used).
author | Mikael Berthe <mikael@lilotux.net> |
---|---|
date | Sat, 07 Nov 2015 12:21:12 +0100 |
parents | 170597f5365b |
children | 377b6a52b25f |
rev | line source |
---|---|
241 | 1 /* |
2 * utils.c -- Various utility functions | |
393 | 3 * |
2134
fc7a758ebbde
Remove deprecated options comments, update headers
Mikael Berthe <mikael@lilotux.net>
parents:
2133
diff
changeset
|
4 * Copyright (C) 2005-2014 Mikael Berthe <mikael@lilotux.net> |
1599 | 5 * Some of the ut_* functions are derived from Cabber debug/log code. |
1361 | 6 * from_iso8601() comes from the Pidgin (libpurple) project. |
241 | 7 * |
8 * This program is free software; you can redistribute it and/or modify | |
9 * it under the terms of the GNU General Public License as published by | |
10 * the Free Software Foundation; either version 2 of the License, or (at | |
11 * your option) any later version. | |
12 * | |
13 * This program is distributed in the hope that it will be useful, but | |
14 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 * General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU General Public License | |
19 * along with this program; if not, write to the Free Software | |
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 | |
21 * USA | |
22 */ | |
23 | |
1639 | 24 #include <config.h> |
25 | |
24 | 26 #include <stdio.h> |
27 #include <stdlib.h> | |
77 | 28 #include <string.h> |
24 | 29 #include <stdarg.h> |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
30 #include <errno.h> |
802
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
31 |
1639 | 32 #ifdef HAVE_LIBIDN |
33 #include <idna.h> | |
34 #include <stringprep.h> | |
35 static char idnprep[1024]; | |
36 #endif | |
37 | |
38 #include <glib.h> | |
1598 | 39 #include <glib/gprintf.h> |
40 | |
802
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
41 /* For Cygwin (thanks go to Yitzchak Scott-Thoennes) */ |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
42 #ifdef __CYGWIN__ |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
43 # define timezonevar |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
44 extern long timezone; |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
45 #endif |
24 | 46 #include <time.h> |
362
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
47 #include <unistd.h> |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
48 #include <sys/types.h> |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
49 #include <sys/stat.h> |
452 | 50 #include <ctype.h> |
24 | 51 |
977
5b01de4ac5e1
Cosmetic changes
Alexis Hildebrandt <afh [at] 2drop [dot] net>
parents:
952
diff
changeset
|
52 #include "utils.h" |
378
2e6c7b1440d1
Improve debugging/logging
Mikael Berthe <mikael@lilotux.net>
parents:
374
diff
changeset
|
53 #include "logprint.h" |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
54 #include "settings.h" |
1897
efd7c4c34ff2
Display mcabber version when starting a trace log
Mikael Berthe <mikael@lilotux.net>
parents:
1859
diff
changeset
|
55 #include "main.h" |
241 | 56 |
76 | 57 static int DebugEnabled; |
77 | 58 static char *FName; |
24 | 59 |
1598 | 60 // jidtodisp(jid) |
61 // Strips the resource part from the jid | |
62 // The caller should g_free the result after use. | |
63 char *jidtodisp(const char *fjid) | |
64 { | |
65 char *ptr; | |
66 char *alias; | |
67 | |
1910
3695266e16c7
Fix error presence packet handling.
Mikael Berthe <mikael@lilotux.net>
parents:
1897
diff
changeset
|
68 if (!fjid) { |
3695266e16c7
Fix error presence packet handling.
Mikael Berthe <mikael@lilotux.net>
parents:
1897
diff
changeset
|
69 scr_LogPrint(LPRINT_LOGNORM, "** jidtodisp: NULL JID, " |
3695266e16c7
Fix error presence packet handling.
Mikael Berthe <mikael@lilotux.net>
parents:
1897
diff
changeset
|
70 "this is probably a bug, please report!"); |
3695266e16c7
Fix error presence packet handling.
Mikael Berthe <mikael@lilotux.net>
parents:
1897
diff
changeset
|
71 return NULL; |
3695266e16c7
Fix error presence packet handling.
Mikael Berthe <mikael@lilotux.net>
parents:
1897
diff
changeset
|
72 } |
3695266e16c7
Fix error presence packet handling.
Mikael Berthe <mikael@lilotux.net>
parents:
1897
diff
changeset
|
73 |
1598 | 74 alias = g_strdup(fjid); |
75 | |
76 if ((ptr = strchr(alias, JID_RESOURCE_SEPARATOR)) != NULL) { | |
77 *ptr = 0; | |
78 } | |
79 return alias; | |
80 } | |
81 | |
2111 | 82 // The caller must free the string after use. |
1611
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
83 char *jid_get_username(const char *fjid) |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
84 { |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
85 char *ptr; |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
86 char *username; |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
87 |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
88 username = g_strdup(fjid); |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
89 if ((ptr = strchr(username, JID_DOMAIN_SEPARATOR)) != NULL) { |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
90 *ptr = 0; |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
91 } |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
92 return username; |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
93 } |
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1599
diff
changeset
|
94 |
2111 | 95 // The caller must free the string after use. |
2103
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
96 char *get_servername(const char *username, const char *servername) |
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
97 { |
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
98 char *ptr; |
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
99 char *server; |
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
100 |
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
101 if ((ptr = strchr(username, JID_DOMAIN_SEPARATOR)) != NULL) { |
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
102 server = g_strdup(ptr+1); |
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
103 return server; |
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
104 } |
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
105 |
2111 | 106 return g_strdup(servername); |
2103
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
107 } |
1210a22726d3
We can determine if the server supports carbons. By means of XEP-0030: Service
Roeland Jago Douma <roeland@famdouma.nl>
parents:
2050
diff
changeset
|
108 |
2111 | 109 // The caller must free the string after use. |
1598 | 110 char *compose_jid(const char *username, const char *servername, |
111 const char *resource) | |
112 { | |
113 char *fjid; | |
114 | |
115 if (!strchr(username, JID_DOMAIN_SEPARATOR)) { | |
116 fjid = g_strdup_printf("%s%c%s%c%s", username, | |
117 JID_DOMAIN_SEPARATOR, servername, | |
118 JID_RESOURCE_SEPARATOR, resource); | |
119 } else { | |
120 fjid = g_strdup_printf("%s%c%s", username, | |
121 JID_RESOURCE_SEPARATOR, resource); | |
122 } | |
123 return fjid; | |
124 } | |
125 | |
126 gboolean jid_equal(const char *jid1, const char *jid2) | |
127 { | |
128 char *a,*b; | |
129 int ret; | |
130 if (!jid1 && !jid2) | |
131 return TRUE; | |
132 if (!jid1 || !jid2) | |
133 return FALSE; | |
134 | |
135 a = jidtodisp(jid1); | |
136 b = jidtodisp(jid2); | |
137 ret = strcasecmp(a, b); | |
138 g_free(a); | |
139 g_free(b); | |
140 return (ret == 0) ? TRUE : FALSE; | |
141 } | |
142 | |
1167
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
143 // expand_filename(filename) |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
144 // Expand "~/" with the $HOME env. variable in a file name. |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
145 // The caller must free the string after use. |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
146 char *expand_filename(const char *fname) |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
147 { |
1222
75aee46d3aee
Fix a problem with the ssl_ca{file,path} variables expansion
Mikael Berthe <mikael@lilotux.net>
parents:
1205
diff
changeset
|
148 if (!fname) |
75aee46d3aee
Fix a problem with the ssl_ca{file,path} variables expansion
Mikael Berthe <mikael@lilotux.net>
parents:
1205
diff
changeset
|
149 return NULL; |
1167
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
150 if (!strncmp(fname, "~/", 2)) { |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
151 char *homedir = getenv("HOME"); |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
152 if (homedir) |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
153 return g_strdup_printf("%s%s", homedir, fname+1); |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
154 } |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
155 return g_strdup(fname); |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
156 } |
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
157 |
2203
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
158 // fingerprint_to_hex(fprstr, hex, fpr_len) |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
159 // Convert the binary fingerprint fprstr (which is fpr_len bytes long) |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
160 // to a NULL-terminated hexadecimal string hex. |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
161 // The destination array hex should have been preallocated by the caller, |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
162 // and should be big enough (i.e. >= 3*fpr_len bytes). |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
163 void fingerprint_to_hex(const char *fprstr, char *hex, size_t fpr_len) |
1598 | 164 { |
2203
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
165 unsigned int i; |
2198
1591518a33b9
Minor change of the prototype for fingerprint_to_hex()
Mikael Berthe <mikael@lilotux.net>
parents:
2197
diff
changeset
|
166 const unsigned char *fpr = (const unsigned char *)fprstr; |
1598 | 167 char *p; |
168 | |
2197
189abf03ef24
Fix fingerprint management
Mikael Berthe <mikael@lilotux.net>
parents:
2168
diff
changeset
|
169 hex[0] = 0; |
2203
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
170 if (!fpr || fpr_len < 16) return; |
2197
189abf03ef24
Fix fingerprint management
Mikael Berthe <mikael@lilotux.net>
parents:
2168
diff
changeset
|
171 |
2203
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
172 for (p = hex, i = 0; i < fpr_len - 1; i++, p+=3) |
2197
189abf03ef24
Fix fingerprint management
Mikael Berthe <mikael@lilotux.net>
parents:
2168
diff
changeset
|
173 g_snprintf(p, 4, "%02X:", fpr[i]); |
189abf03ef24
Fix fingerprint management
Mikael Berthe <mikael@lilotux.net>
parents:
2168
diff
changeset
|
174 g_snprintf(p, 3, "%02X", fpr[i]); |
1598 | 175 } |
176 | |
2203
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
177 // hex_to_fingerprint(hex, fpr, fpr_len) |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
178 // Convert the hexadecimal fingerprint hex to a byte array fpr[]. |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
179 // The fpr array should have been preallocated with a size >= fpr_len. |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
180 gboolean hex_to_fingerprint(const char *hex, char *fpr, size_t fpr_len) |
1598 | 181 { |
2203
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
182 unsigned int i; |
2197
189abf03ef24
Fix fingerprint management
Mikael Berthe <mikael@lilotux.net>
parents:
2168
diff
changeset
|
183 const char *p; |
1598 | 184 |
2203
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
185 if (fpr_len < 16) return FALSE; |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
186 |
2197
189abf03ef24
Fix fingerprint management
Mikael Berthe <mikael@lilotux.net>
parents:
2168
diff
changeset
|
187 fpr[0] = 0; |
2203
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
188 |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
189 if (strlen(hex) != fpr_len*3 - 1) |
1598 | 190 return FALSE; |
2203
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
191 |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
192 for (i = 0, p = hex; i < fpr_len && *p && *(p+1); i++, p += 3) { |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
193 // Check we have two hex digits followed by a colon (or end of string) |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
194 if (!isxdigit(*p) || !isxdigit(*(p+1))) |
2197
189abf03ef24
Fix fingerprint management
Mikael Berthe <mikael@lilotux.net>
parents:
2168
diff
changeset
|
195 return FALSE; |
2203
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
196 if (*(p+2) && (*(p+2) != ':')) |
170597f5365b
Use more generic routines to convert fingerprints to/from hexadecimal
Mikael Berthe <mikael@lilotux.net>
parents:
2198
diff
changeset
|
197 return FALSE; |
2197
189abf03ef24
Fix fingerprint management
Mikael Berthe <mikael@lilotux.net>
parents:
2168
diff
changeset
|
198 fpr[i] = (char)g_ascii_strtoull(p, NULL, 16); |
189abf03ef24
Fix fingerprint management
Mikael Berthe <mikael@lilotux.net>
parents:
2168
diff
changeset
|
199 } |
1598 | 200 return TRUE; |
201 } | |
202 | |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
203 static gboolean tracelog_create(void) |
24 | 204 { |
77 | 205 FILE *fp; |
428
4470868f90e5
Check the tracelog file actually belongs to the user (if logging enabled)
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
206 struct stat buf; |
4470868f90e5
Check the tracelog file actually belongs to the user (if logging enabled)
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
207 int err; |
1897
efd7c4c34ff2
Display mcabber version when starting a trace log
Mikael Berthe <mikael@lilotux.net>
parents:
1859
diff
changeset
|
208 char *v; |
77 | 209 |
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
364
diff
changeset
|
210 fp = fopen(FName, "a"); |
378
2e6c7b1440d1
Improve debugging/logging
Mikael Berthe <mikael@lilotux.net>
parents:
374
diff
changeset
|
211 if (!fp) { |
2135
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
212 scr_LogPrint(LPRINT_NORMAL, "ERROR: Cannot open tracelog file: %s", |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
213 strerror(errno)); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
214 return FALSE; |
378
2e6c7b1440d1
Improve debugging/logging
Mikael Berthe <mikael@lilotux.net>
parents:
374
diff
changeset
|
215 } |
428
4470868f90e5
Check the tracelog file actually belongs to the user (if logging enabled)
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
216 |
4470868f90e5
Check the tracelog file actually belongs to the user (if logging enabled)
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
217 err = fstat(fileno(fp), &buf); |
4470868f90e5
Check the tracelog file actually belongs to the user (if logging enabled)
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
218 if (err || buf.st_uid != geteuid()) { |
4470868f90e5
Check the tracelog file actually belongs to the user (if logging enabled)
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
219 fclose(fp); |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
220 if (err) |
2135
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
221 scr_LogPrint(LPRINT_NORMAL, "ERROR: cannot stat the tracelog file: %s", |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
222 strerror(errno)); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
223 else |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
224 scr_LogPrint(LPRINT_NORMAL, "ERROR: tracelog file does not belong to you!"); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
225 return FALSE; |
428
4470868f90e5
Check the tracelog file actually belongs to the user (if logging enabled)
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
226 } |
2135
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
227 |
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
228 if (fchmod(fileno(fp), S_IRUSR|S_IWUSR)) { |
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
229 scr_LogPrint(LPRINT_NORMAL, "WARNING: Cannot set tracelog file permissions: %s", |
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
230 strerror(errno)); |
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
231 } |
428
4470868f90e5
Check the tracelog file actually belongs to the user (if logging enabled)
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
232 |
1897
efd7c4c34ff2
Display mcabber version when starting a trace log
Mikael Berthe <mikael@lilotux.net>
parents:
1859
diff
changeset
|
233 v = mcabber_version(); |
efd7c4c34ff2
Display mcabber version when starting a trace log
Mikael Berthe <mikael@lilotux.net>
parents:
1859
diff
changeset
|
234 fprintf(fp, "New trace log started. MCabber version %s\n" |
efd7c4c34ff2
Display mcabber version when starting a trace log
Mikael Berthe <mikael@lilotux.net>
parents:
1859
diff
changeset
|
235 "----------------------\n", v); |
efd7c4c34ff2
Display mcabber version when starting a trace log
Mikael Berthe <mikael@lilotux.net>
parents:
1859
diff
changeset
|
236 g_free(v); |
24 | 237 fclose(fp); |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
238 return TRUE; |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
239 } |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
240 |
2111 | 241 // The caller must free the string after use. |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
242 static gchar *tracelog_level_guard(const gchar *key, const gchar *new_value) |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
243 { |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
244 int new_level = 0; |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
245 if (new_value) |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
246 new_level = atoi(new_value); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
247 if (DebugEnabled < 1 && new_level > 0 && FName && !tracelog_create()) |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
248 DebugEnabled = 0; |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
249 else |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
250 DebugEnabled = new_level; |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
251 return g_strdup(new_value); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
252 } |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
253 |
2111 | 254 // The caller must free the string after use. |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
255 static gchar *tracelog_file_guard(const gchar *key, const gchar *new_value) |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
256 { |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
257 gchar *new_fname = NULL; |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
258 |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
259 if (new_value) |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
260 new_fname = expand_filename(new_value); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
261 |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
262 if (g_strcmp0(FName, new_fname)) { |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
263 g_free(FName); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
264 FName = new_fname; |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
265 if (DebugEnabled > 0 && !tracelog_create()) { |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
266 g_free(FName); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
267 FName = NULL; |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
268 } |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
269 } else |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
270 g_free(new_fname); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
271 |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
272 return g_strdup(new_value); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
273 } |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
274 |
1780
e4378fbab5d7
Major API cleanup - bump API to 4
Mikael Berthe <mikael@lilotux.net>
parents:
1729
diff
changeset
|
275 // ut_init_debug() |
2111 | 276 // Install option guards before initial config file parsing. |
1780
e4378fbab5d7
Major API cleanup - bump API to 4
Mikael Berthe <mikael@lilotux.net>
parents:
1729
diff
changeset
|
277 void ut_init_debug(void) |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
278 { |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
279 DebugEnabled = 0; |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
280 FName = NULL; |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
281 settings_set_guard("tracelog_level", tracelog_level_guard); |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
282 settings_set_guard("tracelog_file", tracelog_file_guard); |
24 | 283 } |
284 | |
1780
e4378fbab5d7
Major API cleanup - bump API to 4
Mikael Berthe <mikael@lilotux.net>
parents:
1729
diff
changeset
|
285 void ut_write_log(unsigned int flag, const char *data) |
24 | 286 { |
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
364
diff
changeset
|
287 if (!DebugEnabled || !FName) return; |
393 | 288 |
1617 | 289 if (((DebugEnabled >= 2) && (flag & (LPRINT_LOG|LPRINT_DEBUG))) || |
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
364
diff
changeset
|
290 ((DebugEnabled == 1) && (flag & LPRINT_LOG))) { |
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
364
diff
changeset
|
291 FILE *fp = fopen(FName, "a+"); |
378
2e6c7b1440d1
Improve debugging/logging
Mikael Berthe <mikael@lilotux.net>
parents:
374
diff
changeset
|
292 if (!fp) { |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
293 scr_LogPrint(LPRINT_NORMAL, "ERROR: Cannot open tracelog file: %s.", |
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
294 strerror(errno)); |
378
2e6c7b1440d1
Improve debugging/logging
Mikael Berthe <mikael@lilotux.net>
parents:
374
diff
changeset
|
295 return; |
2e6c7b1440d1
Improve debugging/logging
Mikael Berthe <mikael@lilotux.net>
parents:
374
diff
changeset
|
296 } |
2135
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
297 |
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
298 // Check file permissions again (it could be a new file) |
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
299 fchmod(fileno(fp), S_IRUSR|S_IWUSR); |
361603828d9e
Set the trace log file permissions again when we write to it
Mikael Berthe <mikael@lilotux.net>
parents:
2134
diff
changeset
|
300 |
1531
9f92c0edde1c
Display a warning when writing to the tracelog file fails
Mikael Berthe <mikael@lilotux.net>
parents:
1460
diff
changeset
|
301 if (fputs(data, fp) == EOF) |
1674
f02e7076ccec
Use option guards for tracelog
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
302 scr_LogPrint(LPRINT_NORMAL, "ERROR: Cannot write to tracelog file."); |
24 | 303 fclose(fp); |
304 } | |
305 } | |
306 | |
362
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
307 // checkset_perm(name, setmode) |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
308 // Check the permissions of the "name" file/dir |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
309 // If setmode is true, correct the permissions if they are wrong |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
310 // Return values: -1 == bad file/dir, 0 == success, 1 == cannot correct |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
311 int checkset_perm(const char *name, unsigned int setmode) |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
312 { |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
313 int fd; |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
314 struct stat buf; |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
315 |
816
a6628f0aabc1
Skip file permission checks on Cygwin
Mikael Berthe <mikael@lilotux.net>
parents:
803
diff
changeset
|
316 #ifdef __CYGWIN__ |
1460 | 317 // Permission checking isn't efficient on Cygwin |
816
a6628f0aabc1
Skip file permission checks on Cygwin
Mikael Berthe <mikael@lilotux.net>
parents:
803
diff
changeset
|
318 return 0; |
a6628f0aabc1
Skip file permission checks on Cygwin
Mikael Berthe <mikael@lilotux.net>
parents:
803
diff
changeset
|
319 #endif |
a6628f0aabc1
Skip file permission checks on Cygwin
Mikael Berthe <mikael@lilotux.net>
parents:
803
diff
changeset
|
320 |
1459
d76eff4ed71d
Use stat() to check permissions in checkset_perm() (Dave Holland)
Mikael Berthe <mikael@lilotux.net>
parents:
1458
diff
changeset
|
321 fd = stat(name, &buf); |
362
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
322 if (fd == -1) return -1; |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
323 |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
324 if (buf.st_uid != geteuid()) { |
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
364
diff
changeset
|
325 scr_LogPrint(LPRINT_LOGNORM, "Wrong file owner [%s]", name); |
362
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
326 return 1; |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
327 } |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
328 |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
329 if (buf.st_mode & (S_IRGRP | S_IWGRP | S_IXGRP) || |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
330 buf.st_mode & (S_IROTH | S_IWOTH | S_IXOTH)) { |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
331 if (setmode) { |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
332 mode_t newmode = 0; |
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
364
diff
changeset
|
333 scr_LogPrint(LPRINT_LOGNORM, "Bad permissions [%s]", name); |
362
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
334 if (S_ISDIR(buf.st_mode)) |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
335 newmode |= S_IXUSR; |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
336 newmode |= S_IRUSR | S_IWUSR; |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
337 if (chmod(name, newmode)) { |
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
364
diff
changeset
|
338 scr_LogPrint(LPRINT_LOGNORM, "WARNING: Failed to correct permissions!"); |
362
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
339 return 1; |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
340 } |
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
364
diff
changeset
|
341 scr_LogPrint(LPRINT_LOGNORM, "Permissions have been corrected"); |
362
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
342 } else { |
374
bd5638c21834
Improve logging system (traces)
Mikael Berthe <mikael@lilotux.net>
parents:
364
diff
changeset
|
343 scr_LogPrint(LPRINT_LOGNORM, "WARNING: Bad permissions [%s]", name); |
362
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
344 return 1; |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
345 } |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
346 } |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
347 |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
348 return 0; |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
349 } |
d8f147d6e872
Check directory and config file permissions
Mikael Berthe <mikael@lilotux.net>
parents:
281
diff
changeset
|
350 |
524
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
351 const char *ut_get_tmpdir(void) |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
352 { |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
353 static const char *tmpdir; |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
354 const char *tmpvars[] = { "MCABBERTMPDIR", "TMP", "TMPDIR", "TEMP" }; |
735 | 355 unsigned int i; |
524
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
356 |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
357 if (tmpdir) |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
358 return tmpdir; |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
359 |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
360 for (i = 0; i < (sizeof(tmpvars) / sizeof(const char *)); i++) { |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
361 tmpdir = getenv(tmpvars[i]); |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
362 if (tmpdir && tmpdir[0] && tmpdir[0] == '/' && tmpdir[1]) { |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
363 // Looks ok. |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
364 return tmpdir; |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
365 } |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
366 } |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
367 |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
368 // Default temporary directory |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
369 tmpdir = "/tmp"; |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
370 return tmpdir; |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
371 } |
05c0e55c4bb1
Pass message body to external command
Mikael Berthe <mikael@lilotux.net>
parents:
463
diff
changeset
|
372 |
241 | 373 // to_iso8601(dststr, timestamp) |
374 // Convert timestamp to iso8601 format, and store it in dststr. | |
375 // NOTE: dststr should be at last 19 chars long. | |
376 // Return should be 0 | |
377 int to_iso8601(char *dststr, time_t timestamp) | |
378 { | |
379 struct tm *tm_time; | |
380 int ret; | |
381 | |
382 tm_time = gmtime(×tamp); | |
383 | |
384 ret = snprintf(dststr, 19, "%.4d%02d%02dT%02d:%02d:%02dZ", | |
1458
17e95be6c39b
time_t fix from the MirBSD port (Thorsten Glaser)
Mikael Berthe <mikael@lilotux.net>
parents:
1452
diff
changeset
|
385 (int)(1900+tm_time->tm_year), tm_time->tm_mon+1, tm_time->tm_mday, |
241 | 386 tm_time->tm_hour, tm_time->tm_min, tm_time->tm_sec); |
387 | |
388 return ((ret == -1) ? -1 : 0); | |
389 } | |
390 | |
391 // from_iso8601(timestamp, utc) | |
1361 | 392 // This function came from the Pidgin project, gaim_str_to_time(). |
241 | 393 // (Actually date may not be pure iso-8601) |
394 // Thanks, guys! | |
802
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
395 // ** Modified by somian 10 Apr 2006 with advice from ysth. |
241 | 396 time_t from_iso8601(const char *timestamp, int utc) |
397 { | |
398 struct tm t; | |
399 time_t retval = 0; | |
400 char buf[32]; | |
401 char *c; | |
402 int tzoff = 0; | |
802
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
403 int hms_succ = 0; |
1458
17e95be6c39b
time_t fix from the MirBSD port (Thorsten Glaser)
Mikael Berthe <mikael@lilotux.net>
parents:
1452
diff
changeset
|
404 int tmpyear; |
241 | 405 |
406 time(&retval); | |
407 localtime_r(&retval, &t); | |
408 | |
463
339e85418b49
from_iso8601(): set time to 00:00:00 if not specified
Mikael Berthe <mikael@lilotux.net>
parents:
456
diff
changeset
|
409 /* Reset time to midnight (00:00:00) */ |
339e85418b49
from_iso8601(): set time to 00:00:00 if not specified
Mikael Berthe <mikael@lilotux.net>
parents:
456
diff
changeset
|
410 t.tm_hour = t.tm_min = t.tm_sec = 0; |
339e85418b49
from_iso8601(): set time to 00:00:00 if not specified
Mikael Berthe <mikael@lilotux.net>
parents:
456
diff
changeset
|
411 |
241 | 412 snprintf(buf, sizeof(buf), "%s", timestamp); |
413 c = buf; | |
414 | |
415 /* 4 digit year */ | |
1458
17e95be6c39b
time_t fix from the MirBSD port (Thorsten Glaser)
Mikael Berthe <mikael@lilotux.net>
parents:
1452
diff
changeset
|
416 if (!sscanf(c, "%04d", &tmpyear)) return 0; |
17e95be6c39b
time_t fix from the MirBSD port (Thorsten Glaser)
Mikael Berthe <mikael@lilotux.net>
parents:
1452
diff
changeset
|
417 t.tm_year = tmpyear; |
241 | 418 c+=4; |
419 if (*c == '-') | |
420 c++; | |
421 | |
422 t.tm_year -= 1900; | |
423 | |
424 /* 2 digit month */ | |
425 if (!sscanf(c, "%02d", &t.tm_mon)) return 0; | |
426 c+=2; | |
427 if (*c == '-') | |
428 c++; | |
429 | |
430 t.tm_mon -= 1; | |
431 | |
432 /* 2 digit day */ | |
433 if (!sscanf(c, "%02d", &t.tm_mday)) return 0; | |
434 c+=2; | |
435 if (*c == 'T' || *c == '.') { /* we have more than a date, keep going */ | |
436 c++; /* skip the "T" */ | |
437 | |
438 /* 2 digit hour */ | |
802
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
439 if (sscanf(c, "%02d:%02d:%02d", &t.tm_hour, &t.tm_min, &t.tm_sec) == 3) |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
440 { |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
441 hms_succ = 1; |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
442 c += 8; |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
443 } |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
444 else if (sscanf(c, "%02d%02d%02d", &t.tm_hour, &t.tm_min, &t.tm_sec) == 3) |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
445 { |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
446 hms_succ = 1; |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
447 c += 6; |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
448 } |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
449 |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
450 if (hms_succ) { |
241 | 451 int tzhrs, tzmins; |
802
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
452 |
241 | 453 if (*c == '.') /* dealing with precision we don't care about */ |
2168
87244845fd9c
Handle fractional seconds with more (or less) than 3 digits in timestamps
Mikael Berthe <mikael@lilotux.net>
parents:
2135
diff
changeset
|
454 while (isdigit(*++c)) |
87244845fd9c
Handle fractional seconds with more (or less) than 3 digits in timestamps
Mikael Berthe <mikael@lilotux.net>
parents:
2135
diff
changeset
|
455 ; |
241 | 456 |
457 if ((*c == '+' || *c == '-') && | |
458 sscanf(c+1, "%02d:%02d", &tzhrs, &tzmins)) { | |
459 tzoff = tzhrs*60*60 + tzmins*60; | |
460 if (*c == '+') | |
461 tzoff *= -1; | |
462 } | |
463 | |
464 if (tzoff || utc) { | |
802
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
465 #ifdef HAVE_TM_GMTOFF |
241 | 466 tzoff += t.tm_gmtoff; |
802
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
467 #else |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
468 # ifdef HAVE_TIMEZONE |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
469 tzset(); /* making sure */ |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
470 tzoff -= timezone; |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
471 # endif |
dd860da62002
Enable use on systems that do not have tm_gmtoff including Cygwin
Soren Andersen <somian@pobox.com>
parents:
735
diff
changeset
|
472 #endif |
241 | 473 } |
474 } | |
475 } | |
476 | |
477 t.tm_isdst = -1; | |
478 | |
479 retval = mktime(&t); | |
480 | |
481 retval += tzoff; | |
482 | |
483 return retval; | |
484 } | |
419 | 485 |
452 | 486 /** |
487 * Derived from libjabber/jid.c, because the libjabber version is not | |
488 * really convenient for our usage. | |
489 * | |
490 * Check if the full JID is valid | |
491 * Return 0 if it is valid, non zero otherwise | |
492 */ | |
1292
382ec54b584e
Muc nick coloring functionality
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1241
diff
changeset
|
493 int check_jid_syntax(const char *fjid) |
452 | 494 { |
1292
382ec54b584e
Muc nick coloring functionality
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1241
diff
changeset
|
495 const char *str; |
382ec54b584e
Muc nick coloring functionality
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1241
diff
changeset
|
496 const char *domain, *resource; |
452 | 497 int domlen; |
1639 | 498 #ifdef HAVE_LIBIDN |
1641
c3c7d6d0348f
Remove (probably) unnecessary check
Mikael Berthe <mikael@lilotux.net>
parents:
1640
diff
changeset
|
499 char *idnpp; |
1639 | 500 int r; |
501 #endif | |
452 | 502 |
1058 | 503 if (!fjid) return 1; |
452 | 504 |
1058 | 505 domain = strchr(fjid, JID_DOMAIN_SEPARATOR); |
452 | 506 |
456
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
507 /* the username is optional */ |
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
508 if (!domain) { |
1058 | 509 domain = fjid; |
456
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
510 } else { |
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
511 /* node identifiers may not be longer than 1023 bytes */ |
1058 | 512 if ((domain == fjid) || (domain-fjid > 1023)) |
456
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
513 return 1; |
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
514 domain++; |
452 | 515 |
1639 | 516 #ifdef HAVE_LIBIDN |
517 idnpp = idnprep; | |
518 str = fjid; | |
519 while (*str != JID_DOMAIN_SEPARATOR) | |
520 *idnpp++ = *str++; | |
521 *idnpp = 0; | |
522 | |
523 r = stringprep(idnprep, 1023, 0, stringprep_xmpp_nodeprep); | |
524 if (r != STRINGPREP_OK || !idnprep[0]) | |
525 return 1; | |
526 /* the username looks okay */ | |
527 #else | |
456
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
528 /* check for low and invalid ascii characters in the username */ |
1058 | 529 for (str = fjid; *str != JID_DOMAIN_SEPARATOR; str++) { |
977
5b01de4ac5e1
Cosmetic changes
Alexis Hildebrandt <afh [at] 2drop [dot] net>
parents:
952
diff
changeset
|
530 if (*str <= ' ' || *str == ':' || *str == JID_DOMAIN_SEPARATOR || |
456
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
531 *str == '<' || *str == '>' || *str == '\'' || |
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
532 *str == '"' || *str == '&') { |
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
533 return 1; |
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
534 } |
452 | 535 } |
456
471c9ccde028
Make username optional in check_jid_syntax()
Mikael Berthe <mikael@lilotux.net>
parents:
452
diff
changeset
|
536 /* the username is okay as far as we can tell without LIBIDN */ |
1639 | 537 #endif |
452 | 538 } |
539 | |
977
5b01de4ac5e1
Cosmetic changes
Alexis Hildebrandt <afh [at] 2drop [dot] net>
parents:
952
diff
changeset
|
540 resource = strchr(domain, JID_RESOURCE_SEPARATOR); |
452 | 541 |
542 /* the resource is optional */ | |
543 if (resource) { | |
544 domlen = resource - domain; | |
545 resource++; | |
546 /* resources may not be longer than 1023 bytes */ | |
547 if ((*resource == '\0') || strlen(resource) > 1023) | |
548 return 1; | |
1639 | 549 #ifdef HAVE_LIBIDN |
550 strncpy(idnprep, resource, sizeof(idnprep)); | |
551 r = stringprep(idnprep, 1023, 0, stringprep_xmpp_resourceprep); | |
552 if (r != STRINGPREP_OK || !idnprep[0]) | |
553 return 1; | |
554 #endif | |
452 | 555 } else { |
556 domlen = strlen(domain); | |
557 } | |
558 | |
559 /* there must be a domain identifier */ | |
560 if (domlen == 0) return 1; | |
561 | |
562 /* and it must not be longer than 1023 bytes */ | |
563 if (domlen > 1023) return 1; | |
564 | |
1859
a20701a2840c
"." is not a valid Jabber domain name
Mikael Berthe <mikael@lilotux.net>
parents:
1811
diff
changeset
|
565 /* /.+/ is not a valid domain name pattern */ |
a20701a2840c
"." is not a valid Jabber domain name
Mikael Berthe <mikael@lilotux.net>
parents:
1811
diff
changeset
|
566 for (str = domain; *str && *str != JID_RESOURCE_SEPARATOR; str++) |
a20701a2840c
"." is not a valid Jabber domain name
Mikael Berthe <mikael@lilotux.net>
parents:
1811
diff
changeset
|
567 if (*str != '.') break; |
a20701a2840c
"." is not a valid Jabber domain name
Mikael Berthe <mikael@lilotux.net>
parents:
1811
diff
changeset
|
568 if (!*str || *str == JID_RESOURCE_SEPARATOR) |
a20701a2840c
"." is not a valid Jabber domain name
Mikael Berthe <mikael@lilotux.net>
parents:
1811
diff
changeset
|
569 return 1; /* domain contains only dots */ |
a20701a2840c
"." is not a valid Jabber domain name
Mikael Berthe <mikael@lilotux.net>
parents:
1811
diff
changeset
|
570 |
1639 | 571 #ifdef HAVE_LIBIDN |
572 idnpp = idnprep; | |
573 str = domain; | |
574 while (*str != '\0' && *str != JID_RESOURCE_SEPARATOR) | |
575 *idnpp++ = *str++; | |
576 *idnpp = 0; | |
577 | |
578 r = stringprep_nameprep(idnprep, 1023); | |
579 if (r != STRINGPREP_OK || !idnprep[0]) | |
580 return 1; | |
581 | |
1641
c3c7d6d0348f
Remove (probably) unnecessary check
Mikael Berthe <mikael@lilotux.net>
parents:
1640
diff
changeset
|
582 if (idna_to_ascii_8z(idnprep, &idnpp, IDNA_USE_STD3_ASCII_RULES) != |
1639 | 583 IDNA_SUCCESS) |
584 return 1; | |
585 else | |
1641
c3c7d6d0348f
Remove (probably) unnecessary check
Mikael Berthe <mikael@lilotux.net>
parents:
1640
diff
changeset
|
586 free(idnpp); |
1639 | 587 #else |
452 | 588 /* make sure the hostname is valid characters */ |
977
5b01de4ac5e1
Cosmetic changes
Alexis Hildebrandt <afh [at] 2drop [dot] net>
parents:
952
diff
changeset
|
589 for (str = domain; *str != '\0' && *str != JID_RESOURCE_SEPARATOR; str++) { |
452 | 590 if (!(isalnum(*str) || *str == '.' || *str == '-' || *str == '_')) |
591 return 1; | |
592 } | |
1639 | 593 #endif |
452 | 594 |
1639 | 595 /* it's okay as far as we can tell */ |
452 | 596 return 0; |
597 } | |
598 | |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
599 |
1106 | 600 inline void mc_strtolower(char *str) |
452 | 601 { |
602 if (!str) return; | |
603 for ( ; *str; str++) | |
604 *str = tolower(*str); | |
605 } | |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
606 |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
607 // strip_arg_special_chars(string) |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
608 // Remove quotes and backslashes before an escaped quote |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
609 // Only quotes need a backslash |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
610 // Ex.: ["a b"] -> [a b]; [a\"b] -> [a"b] |
554
2424bbf0a6db
Some more work on do_room()
Mikael Berthe <mikael@lilotux.net>
parents:
553
diff
changeset
|
611 void strip_arg_special_chars(char *s) |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
612 { |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
613 int instring = FALSE; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
614 int escape = FALSE; |
2133
69d00a118c0c
Fix ANSI C-incompatible change
Mikael Berthe <mikael@lilotux.net>
parents:
2119
diff
changeset
|
615 char *p, *t; |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
616 |
979
ea939ff047d8
Improve /buffer search_*
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
617 if (!s) return; |
ea939ff047d8
Improve /buffer search_*
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
618 |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
619 for (p = s; *p; p++) { |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
620 if (*p == '"') { |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
621 if (!escape) { |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
622 instring = !instring; |
2119
3b26f3a58cb9
Fix command line issue reported by Minos
Mikael Berthe <mikael@lilotux.net>
parents:
2111
diff
changeset
|
623 //memmove(p, p+1, strlen(p)); |
2133
69d00a118c0c
Fix ANSI C-incompatible change
Mikael Berthe <mikael@lilotux.net>
parents:
2119
diff
changeset
|
624 for (t=p; *t; t++) |
2119
3b26f3a58cb9
Fix command line issue reported by Minos
Mikael Berthe <mikael@lilotux.net>
parents:
2111
diff
changeset
|
625 *t = *(t+1); |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
626 p--; |
1452
83e275dca409
Fix escaping bug in strip_arg_special_chars()
Mikael Berthe <mikael@lilotux.net>
parents:
1440
diff
changeset
|
627 } else |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
628 escape = FALSE; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
629 } else if (*p == '\\') { |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
630 if (!escape) { |
2119
3b26f3a58cb9
Fix command line issue reported by Minos
Mikael Berthe <mikael@lilotux.net>
parents:
2111
diff
changeset
|
631 //memmove(p, p+1, strlen(p)); |
2133
69d00a118c0c
Fix ANSI C-incompatible change
Mikael Berthe <mikael@lilotux.net>
parents:
2119
diff
changeset
|
632 for (t=p; *t; t++) |
2119
3b26f3a58cb9
Fix command line issue reported by Minos
Mikael Berthe <mikael@lilotux.net>
parents:
2111
diff
changeset
|
633 *t = *(t+1); |
1452
83e275dca409
Fix escaping bug in strip_arg_special_chars()
Mikael Berthe <mikael@lilotux.net>
parents:
1440
diff
changeset
|
634 p--; |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
635 } |
1452
83e275dca409
Fix escaping bug in strip_arg_special_chars()
Mikael Berthe <mikael@lilotux.net>
parents:
1440
diff
changeset
|
636 escape = !escape; |
83e275dca409
Fix escaping bug in strip_arg_special_chars()
Mikael Berthe <mikael@lilotux.net>
parents:
1440
diff
changeset
|
637 } else |
83e275dca409
Fix escaping bug in strip_arg_special_chars()
Mikael Berthe <mikael@lilotux.net>
parents:
1440
diff
changeset
|
638 escape = FALSE; |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
639 } |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
640 } |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
641 |
554
2424bbf0a6db
Some more work on do_room()
Mikael Berthe <mikael@lilotux.net>
parents:
553
diff
changeset
|
642 // split_arg(arg, n, preservelast) |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
643 // Split the string arg into a maximum of n pieces, taking care of |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
644 // double quotes. |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
645 // Return a null-terminated array of strings. This array should be freed |
1167
9726c78a91f3
Allow '~' (HOME directory) in config options
Mikael Berthe <mikael@lilotux.net>
parents:
1122
diff
changeset
|
646 // by the caller after use, for example with free_arg_lst(). |
559
4eb579399613
Fix a small bug in split_arg()
Mikael Berthe <mikael@lilotux.net>
parents:
556
diff
changeset
|
647 // If dontstriplast is true, the Nth argument isn't stripped (i.e. no |
4eb579399613
Fix a small bug in split_arg()
Mikael Berthe <mikael@lilotux.net>
parents:
556
diff
changeset
|
648 // processing of quote chars) |
554
2424bbf0a6db
Some more work on do_room()
Mikael Berthe <mikael@lilotux.net>
parents:
553
diff
changeset
|
649 char **split_arg(const char *arg, unsigned int n, int dontstriplast) |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
650 { |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
651 char **arglst; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
652 const char *p, *start, *end; |
735 | 653 unsigned int i = 0; |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
654 int instring = FALSE; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
655 int escape = FALSE; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
656 |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
657 arglst = g_new0(char*, n+1); |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
658 |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
659 if (!arg || !n) return arglst; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
660 |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
661 // Skip leading space |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
662 for (start = arg; *start && *start == ' '; start++) ; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
663 // End of string pointer |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
664 for (end = start; *end; end++) ; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
665 // Skip trailing space |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
666 while (end > start+1 && *(end-1) == ' ') |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
667 end--; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
668 |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
669 for (p = start; p < end; p++) { |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
670 if (*p == '"' && !escape) |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
671 instring = !instring; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
672 if (*p == '\\' && !escape) |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
673 escape = TRUE; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
674 else if (escape) |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
675 escape = FALSE; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
676 if (*p == ' ' && !instring && i+1 < n) { |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
677 // end of parameter |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
678 *(arglst+i) = g_strndup(start, p-start); |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
679 strip_arg_special_chars(*(arglst+i)); |
556 | 680 for (start = p+1; *start && *start == ' '; start++) ; |
1367 | 681 p = start-1; |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
682 i++; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
683 } |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
684 } |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
685 |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
686 if (start < end) { |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
687 *(arglst+i) = g_strndup(start, end-start); |
559
4eb579399613
Fix a small bug in split_arg()
Mikael Berthe <mikael@lilotux.net>
parents:
556
diff
changeset
|
688 if (!dontstriplast || i+1 < n) |
554
2424bbf0a6db
Some more work on do_room()
Mikael Berthe <mikael@lilotux.net>
parents:
553
diff
changeset
|
689 strip_arg_special_chars(*(arglst+i)); |
551
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
690 } |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
691 |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
692 return arglst; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
693 } |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
694 |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
695 // free_arg_lst(arglst) |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
696 // Free an array allocated by split_arg() |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
697 void free_arg_lst(char **arglst) |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
698 { |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
699 char **arg_elt; |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
700 |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
701 for (arg_elt = arglst; *arg_elt; arg_elt++) |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
702 g_free(*arg_elt); |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
703 g_free(arglst); |
c71699efa5cc
Add split_arg() / free_arg_lst()
Mikael Berthe <mikael@lilotux.net>
parents:
524
diff
changeset
|
704 } |
576 | 705 |
655
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
706 // replace_nl_with_dots(bufstr) |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
707 // Replace '\n' with "(...)" (or with a NUL if the string is too short) |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
708 void replace_nl_with_dots(char *bufstr) |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
709 { |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
710 char *p = strchr(bufstr, '\n'); |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
711 if (p) { |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
712 if (strlen(p) >= 5) |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
713 strcpy(p, "(...)"); |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
714 else |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
715 *p = 0; |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
716 } |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
717 } |
de6837908702
Use "(...)" when cutting a multi-line status message in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
580
diff
changeset
|
718 |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
719 // ut_expand_tabs(text) |
1122
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
720 // Expand tabs and filter out some bad chars in string text. |
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
721 // If there is no tab and no bad chars in the string, a pointer to text |
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
722 // is returned (be careful _not_ to free the pointer in this case). |
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
723 // If there are some tabs or bad chars, a new string with expanded chars |
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
724 // and no bad chars is returned; this is up to the caller to free this |
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
725 // string after use. |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
726 char *ut_expand_tabs(const char *text) |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
727 { |
1568
e89787ee40f7
Fix tab expansion when using say_to -f
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1531
diff
changeset
|
728 char *xtext, *linestart; |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
729 char *p, *q; |
1122
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
730 guint n = 0, bc = 0; |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
731 |
2049
0ba755e5dc48
ut_expand_tabs: Check the argument is not null
Mikael Berthe <mikael@lilotux.net>
parents:
1910
diff
changeset
|
732 if (!text) |
0ba755e5dc48
ut_expand_tabs: Check the argument is not null
Mikael Berthe <mikael@lilotux.net>
parents:
1910
diff
changeset
|
733 return NULL; |
0ba755e5dc48
ut_expand_tabs: Check the argument is not null
Mikael Berthe <mikael@lilotux.net>
parents:
1910
diff
changeset
|
734 |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
735 xtext = (char*)text; |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
736 for (p=xtext; *p; p++) |
1122
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
737 if (*p == '\t') |
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
738 n++; |
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
739 else if (*p == '\x0d') |
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
740 bc++; |
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
741 // XXX Are there other special chars we should filter out? |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
742 |
1122
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
743 if (!n && !bc) |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
744 return (char*)text; |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
745 |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
746 xtext = g_new(char, strlen(text) + 1 + 8*n); |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
747 p = (char*)text; |
1568
e89787ee40f7
Fix tab expansion when using say_to -f
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1531
diff
changeset
|
748 q = linestart = xtext; |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
749 do { |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
750 if (*p == '\t') { |
1568
e89787ee40f7
Fix tab expansion when using say_to -f
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1531
diff
changeset
|
751 do { *q++ = ' '; } while ((q-linestart)%8); |
1122
648fe6f715a6
Filter out ^M (0x0d) characters in incoming messages
Mikael Berthe <mikael@lilotux.net>
parents:
1106
diff
changeset
|
752 } else if (*p != '\x0d') { |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
753 *q++ = *p; |
1568
e89787ee40f7
Fix tab expansion when using say_to -f
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1531
diff
changeset
|
754 if (*p =='\n') |
e89787ee40f7
Fix tab expansion when using say_to -f
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1531
diff
changeset
|
755 linestart = q; |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
756 } |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
757 } while (*p++); |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
758 |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
759 return xtext; |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
760 } |
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
761 |
2050
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
762 // ut_unescape_tabs_cr(text) |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
763 // Expand CR or TAB character sequences (\n, \t) in string text. |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
764 // If there is no CR/TAB in text, then the original pointer is returned |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
765 // (be careful _not_ to free the pointer in this case). |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
766 // If there are some unescaped sequences, a new string with those chars |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
767 // replaced with real newline/tab characters is allocated; in this case |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
768 // this is up to the caller to free this string after use. |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
769 char *ut_unescape_tabs_cr(const char *text) |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
770 { |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
771 char *xtext, *linestart; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
772 char *p, *q; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
773 |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
774 if (!text) |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
775 return NULL; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
776 |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
777 p = g_strstr_len(text, -1, "\\n"); |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
778 if (!p) { |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
779 p = g_strstr_len(text, -1, "\\t"); |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
780 if (!p) |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
781 return (char*)text; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
782 } |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
783 |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
784 xtext = g_new(char, strlen(text) + 1); |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
785 p = (char*)text; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
786 q = linestart = xtext; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
787 do { |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
788 if (*p == '\\') { |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
789 if (*(p+1) == '\\' && (*(p+2) == 'n' || *(p+2) == 't')) { |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
790 // This is an escaped CR sequence |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
791 *q++ = '\\'; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
792 *q++ = 'n'; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
793 p += 2; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
794 continue; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
795 } |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
796 if (*(p+1) == 'n' || *(p+1) == 't') { |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
797 // This is a CR sequence |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
798 p++; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
799 *q++ = (*p == 'n' ? '\n' : '\t'); |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
800 continue; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
801 } |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
802 } |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
803 *q++ = *p; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
804 } while (*p++); |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
805 |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
806 return xtext; |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
807 } |
998feaa54ef0
Add ut_unescape_tabs_cr()
Mikael Berthe <mikael@lilotux.net>
parents:
2049
diff
changeset
|
808 |
727
1c3620668857
Expand tabs when reading history files
Mikael Berthe <mikael@lilotux.net>
parents:
699
diff
changeset
|
809 |
803
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
810 /* Cygwin's newlib does not have strcasestr() */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
811 /* The author of the code before the endif is |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
812 * Jeffrey Stedfast <fejj@ximian.com> |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
813 * and this code is reusable in compliance with the GPL v2. -- somian */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
814 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
815 #if !defined(HAVE_STRCASESTR) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
816 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
817 # define lowercase(c) (isupper ((int) (c)) ? tolower ((int) (c)) : (int) (c)) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
818 # define bm_index(c, icase) ((icase) ? lowercase (c) : (int) (c)) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
819 # define bm_equal(c1, c2, icase) ((icase) ? lowercase (c1) == lowercase (c2) : (c1) == (c2)) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
820 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
821 /* FIXME: this is just a guess... should really do some performace tests to get an accurate measure */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
822 # define bm_optimal(hlen, nlen) (((hlen) ? (hlen) > 20 : 1) && (nlen) > 10 ? 1 : 0) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
823 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
824 static unsigned char * |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
825 __boyer_moore (const unsigned char *haystack, size_t haystacklen, |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
826 const unsigned char *needle, size_t needlelen, int icase) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
827 { |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
828 register unsigned char *hc_ptr, *nc_ptr; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
829 unsigned char *he_ptr, *ne_ptr, *h_ptr; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
830 size_t skiptable[256], n; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
831 register int i; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
832 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
833 #ifdef BOYER_MOORE_CHECKS |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
834 /* we don't need to do these checks since memmem/strstr/etc do it already */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
835 /* if the haystack is shorter than the needle then we can't possibly match */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
836 if (haystacklen < needlelen) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
837 return NULL; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
838 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
839 /* instant match if the pattern buffer is 0-length */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
840 if (needlelen == 0) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
841 return (unsigned char *) haystack; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
842 #endif /* BOYER_MOORE_CHECKS */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
843 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
844 /* set a pointer at the end of each string */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
845 ne_ptr = (unsigned char *) needle + needlelen - 1; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
846 he_ptr = (unsigned char *) haystack + haystacklen - 1; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
847 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
848 /* create our skip table */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
849 for (i = 0; i < 256; i++) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
850 skiptable[i] = needlelen; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
851 for (nc_ptr = (unsigned char *) needle; nc_ptr < ne_ptr; nc_ptr++) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
852 skiptable[bm_index (*nc_ptr, icase)] = (size_t) (ne_ptr - nc_ptr); |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
853 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
854 h_ptr = (unsigned char *) haystack; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
855 while (haystacklen >= needlelen) { |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
856 hc_ptr = h_ptr + needlelen - 1; /* set the haystack compare pointer */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
857 nc_ptr = ne_ptr; /* set the needle compare pointer */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
858 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
859 /* work our way backwards till they don't match */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
860 for (i = 0; nc_ptr > (unsigned char *) needle; nc_ptr--, hc_ptr--, i++) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
861 if (!bm_equal (*nc_ptr, *hc_ptr, icase)) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
862 break; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
863 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
864 if (!bm_equal (*nc_ptr, *hc_ptr, icase)) { |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
865 n = skiptable[bm_index (*hc_ptr, icase)]; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
866 if (n == needlelen && i) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
867 if (bm_equal (*ne_ptr, ((unsigned char *) needle)[0], icase)) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
868 n--; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
869 h_ptr += n; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
870 haystacklen -= n; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
871 } else |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
872 return (unsigned char *) h_ptr; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
873 } |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
874 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
875 return NULL; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
876 } |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
877 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
878 /* |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
879 * strcasestr: |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
880 * @haystack: string to search |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
881 * @needle: substring to search for |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
882 * |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
883 * Finds the first occurence of the substring @needle within the |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
884 * string @haystack ignoring case. |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
885 * |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
886 * Returns a pointer to the beginning of the substring match within |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
887 * @haystack, or NULL if the substring is not found. |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
888 **/ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
889 char * |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
890 strcasestr (const char *haystack, const char *needle) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
891 { |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
892 register unsigned char *h, *n, *hc, *nc; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
893 size_t needlelen; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
894 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
895 needlelen = strlen (needle); |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
896 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
897 if (needlelen == 0) { |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
898 return (char *) haystack; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
899 } else if (bm_optimal (0, needlelen)) { |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
900 return (char *) __boyer_moore ((const unsigned char *) haystack, |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
901 strlen (haystack), |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
902 (const unsigned char *) needle, |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
903 needlelen, 1); |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
904 } |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
905 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
906 h = (unsigned char *) haystack; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
907 n = (unsigned char *) needle; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
908 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
909 while (*(h + needlelen - 1)) { |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
910 if (lowercase (*h) == lowercase (*n)) { |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
911 for (hc = h + 1, nc = n + 1; *hc && *nc; hc++, nc++) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
912 if (lowercase (*hc) != lowercase (*nc)) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
913 break; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
914 |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
915 if (!*nc) |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
916 return (char *) h; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
917 } |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
918 h++; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
919 } |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
920 return NULL; |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
921 } |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
922 #endif /* !HAVE_STRCASESTR */ |
8f8d8f8157a2
Take care of the strcasestr lacking (Cygwin)
Soren Andersen <somian@pobox.com>
parents:
802
diff
changeset
|
923 |
1203 | 924 // startswith(str, word, ignore_case) |
1192 | 925 // Returns TRUE if string str starts with word. |
1203 | 926 int startswith(const char *str, const char *word, guint ignore_case) |
1192 | 927 { |
1203 | 928 if (ignore_case && !strncasecmp(str, word, strlen(word))) |
929 return TRUE; | |
930 else if (!ignore_case && !strncmp(str, word, strlen(word))) | |
1192 | 931 return TRUE; |
932 return FALSE; | |
933 } | |
934 | |
1811 | 935 /* vim: set et cindent cinoptions=>2\:2(0 ts=2 sw=2: For Vim users... */ |