secur32: Handle padding only records in schan_DecryptMessage().
[wine] / dlls / hhctrl.ocx / stream.c
1 /*
2  * Copyright 2007 Jacek Caban for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include "hhctrl.h"
20 #include "stream.h"
21
22 #include "wine/debug.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(htmlhelp);
25
26 void strbuf_init(strbuf_t *buf)
27 {
28     buf->size = 8;
29     buf->len = 0;
30     buf->buf = heap_alloc(buf->size);
31 }
32
33 void strbuf_zero(strbuf_t *buf)
34 {
35     buf->len = 0;
36 }
37
38 void strbuf_free(strbuf_t *buf)
39 {
40     heap_free(buf->buf);
41 }
42
43 static void strbuf_append(strbuf_t *buf, const char *data, int len)
44 {
45     if(buf->len+len > buf->size) {
46         buf->size = buf->len+len;
47         buf->buf = heap_realloc(buf->buf, buf->size);
48     }
49
50     memcpy(buf->buf+buf->len, data, len);
51     buf->len += len;
52 }
53
54 void stream_init(stream_t *stream, IStream *str)
55 {
56     memset(stream, 0, sizeof(stream_t));
57     stream->str = str;
58 }
59
60 static BOOL stream_chr(stream_t *stream, strbuf_t *buf, char c)
61 {
62     BOOL b = TRUE;
63     ULONG i;
64
65     while(b) {
66         for(i=stream->p; i<stream->size; i++) {
67             if(stream->buf[i] == c) {
68                 b = FALSE;
69                 break;
70             }
71         }
72
73         if(buf && i > stream->p)
74             strbuf_append(buf, stream->buf+stream->p, i-stream->p);
75         stream->p = i;
76
77         if(stream->p == stream->size) {
78             stream->p = 0;
79             IStream_Read(stream->str, stream->buf, sizeof(stream->buf), &stream->size);
80             if(!stream->size)
81                 break;
82         }
83     }
84
85     return stream->size != 0;
86 }
87
88 void get_node_name(strbuf_t *node, strbuf_t *name)
89 {
90     const char *ptr = node->buf+1;
91
92     strbuf_zero(name);
93
94     while(*ptr != '>' && !isspace(*ptr))
95         ptr++;
96
97     strbuf_append(name, node->buf+1, ptr-node->buf-1);
98     strbuf_append(name, "", 1);
99 }
100
101 /* Return the stream content up to the next HTML tag.
102  *
103  * Note: the first returned character is the end of the last tag (>).
104  */
105 BOOL next_content(stream_t *stream, strbuf_t *buf)
106 {
107     if(!stream_chr(stream, buf, '<'))
108         return FALSE;
109
110     return TRUE;
111 }
112
113 BOOL next_node(stream_t *stream, strbuf_t *buf)
114 {
115     if(!stream_chr(stream, NULL, '<'))
116         return FALSE;
117
118     if(!stream_chr(stream, buf, '>'))
119         return FALSE;
120
121     strbuf_append(buf, ">", 2);
122
123     return TRUE;
124 }
125
126 /*
127  * Find the value of a named HTML attribute.
128  *
129  * Note: Attribute names are case insensitive, so it is necessary to
130  * put both the node text and the attribute name in the same case
131  * before attempting a string search.
132  */
133 const char *get_attr(const char *node, const char *name, int *len)
134 {
135     const char *ptr, *ptr2;
136     int name_len, node_len;
137     char name_buf[32];
138     char *node_buf;
139     int i;
140
141     /* Create a lower case copy of the node */
142     node_len = strlen(node)+1;
143     node_buf = heap_alloc(node_len*sizeof(char));
144     if(!node_buf)
145         return NULL;
146     memcpy(node_buf, node, node_len);
147     for(i=0;i<node_len;i++)
148         node_buf[i] = tolower(node_buf[i]);
149     /* Create a lower case copy of the attribute name (search string) */
150     name_len = strlen(name);
151     memcpy(name_buf, name, name_len);
152     for(i=0;i<name_len;i++)
153         name_buf[i] = tolower(name_buf[i]);
154     name_buf[name_len++] = '=';
155     name_buf[name_len++] = '\"';
156     name_buf[name_len] = 0;
157
158     ptr = strstr(node_buf, name_buf);
159     if(!ptr) {
160         WARN("name not found\n");
161         heap_free(node_buf);
162         return NULL;
163     }
164
165     ptr += name_len;
166     ptr2 = strchr(ptr, '\"');
167     if(!ptr2)
168     {
169         heap_free(node_buf);
170         return NULL;
171     }
172
173     *len = ptr2-ptr;
174     /* Return the pointer offset within the original string */
175     ptr = node+(ptr-node_buf);
176
177     heap_free(node_buf);
178     return ptr;
179 }