← Back to branch summary

~ubuntu-branches/debian/sid/rlinetd/sid

« back to all changes in this revision

Viewing changes to buffer.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Luberda
  • Date: 2010-03-20 18:03:45 UTC
  • mfrom: (2.3.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100320180345-x1srfbe2tg00ezsf
Tags: 0.7-1
http://bugs.debian.org/526922
* New upstream version.
* Recommend rsyslog instead of sysklogd (closes: #526922).
* update-inetd:
  + add support for enabling, disabling and removing entries;
  + use ucf for managing generated files;
  + ignore ucf files in rlinetd.conf;
  + make appropriate changes in  postinst and postrm scripts.
* Set debhelper compat level to 7
* Standards-Version: 3.8.4 (no changes). 

Show diffs side-by-side

added added

removed removed

Lines of Context:
buffer.c
1
 
#include <errno.h>
2
 
#include <stdlib.h>
3
 
#include <unistd.h>
4
 
 
5
 
#include "buffer.h"
6
 
#include "error.h"
7
 
 
8
 
static int do_read(int sock, void *buf, int len) {
9
 
        int err;
10
 
        
11
 
        err = read(sock, buf, len);
12
 
        if(err == -1) {
13
 
                switch(errno) {
14
 
                        case EAGAIN:
15
 
                                return 0;
16
 
                                break;
17
 
                        default:
18
 
                                rl_warn("read(%d, %p, %d): %d (%s)", sock, buf, len,
19
 
                                                                errno, strerror(errno));
20
 
                                return -1;
21
 
                }
22
 
        }
23
 
        return err;
24
 
}
25
 
        
26
 
int rlbuf_read(int sock, struct rl_buffer *buf) {
27
 
        int done, err, size;
28
 
        
29
 
        if(!buf) {
30
 
                rl_warn("rlbuf_read called with NULL buf");
31
 
                return 0;
32
 
        }
33
 
        done = 0;
34
 
        err = 0;
35
 
        if(buf->head >= buf->tail) {
36
 
                size = buf->size - buf->head - !buf->tail;
37
 
                if(size) {
38
 
                        if((err = do_read(sock, buf->data + buf->head, size)) < 0)
39
 
                                return err;
40
 
                        buf->head += err;
41
 
                        done += err;
42
 
                        if(err < size)
43
 
                                return err;
44
 
                        if(buf->tail)
45
 
                                buf->head = 0;
46
 
                }
47
 
        }
48
 
        if(buf->tail && (buf->head < buf->tail)) {
49
 
                size = buf->tail - 1;
50
 
                if(size) {
51
 
                        err = do_read(sock, buf->data, size);
52
 
                        if(err < 0)
53
 
                                err = 0;
54
 
                        buf->head += err;
55
 
                        done += err;
56
 
                }
57
 
        }
58
 
        return done;
59
 
}
60
 
 
61
 
static int do_write(int sock, void *buf, int len) {
62
 
        int err;
63
 
        
64
 
        err = write(sock, buf, len);
65
 
        if(err == -1) {
66
 
                switch(errno) {
67
 
                        case EAGAIN:
68
 
                                return 0;
69
 
                                break;
70
 
                        default:
71
 
                                rl_warn("write(%d, %p, %d): %d (%s)", sock, buf, len,
72
 
                                                                errno, strerror(errno));
73
 
                        case EPIPE:
74
 
                                return -1;
75
 
                }
76
 
        }
77
 
        return err;
78
 
}
79
 
 
80
 
int rlbuf_write(int sock, struct rl_buffer *buf) {
81
 
        int done, err, size;
82
 
 
83
 
        if(!buf) {
84
 
                rl_warn("rlbuf_write called with NULL buf");
85
 
                return 0;
86
 
        }
87
 
        done = 0;
88
 
        err = 0;
89
 
        if(buf->head == buf->tail)
90
 
                return 0;
91
 
        if(buf->head > buf->tail)
92
 
                size = buf->head - buf->tail;
93
 
        else
94
 
                size = buf->size - buf->tail;
95
 
        if(size) {
96
 
                if((err = do_write(sock, buf->data + buf->tail, size)) < 0)
97
 
                        return err;
98
 
                buf->tail += err;
99
 
                done += err;
100
 
                if(err < size)
101
 
                        return err;
102
 
                if(buf->tail == buf->size)
103
 
                        buf->tail = 0;
104
 
        }
105
 
        if(buf->tail < buf->head) {
106
 
                size = buf->head - buf->tail;
107
 
                err = do_write(sock, buf->data + buf->tail, size);
108
 
                if(err < 0)
109
 
                        err = 0;
110
 
                buf->tail += err;
111
 
                done += err;
112
 
        }
113
 
        return done;
114
 
}
115
 
 
116
 
int rlbuf_copy(int sock, struct rl_buffer *buf, int offset) {
117
 
        int done, err, size;
118
 
 
119
 
        if(!buf) {
120
 
                rl_warn("rlbuf_write called with NULL buf");
121
 
                return 0;
122
 
        }
123
 
        done = 0;
124
 
        err = 0;
125
 
        if(buf->head == buf->tail)
126
 
                return 0;
127
 
        if(buf->head > buf->tail)
128
 
                size = buf->head - buf->tail;
129
 
        else
130
 
                size = buf->size - buf->tail;
131
 
        if(size <= offset) {
132
 
                offset -= size;
133
 
                size = 0;
134
 
        } 
135
 
        if(size) {
136
 
                if((err = do_write(sock, buf->data + buf->tail + offset, size)) < 0)
137
 
                        return err;
138
 
                done += err;
139
 
                if(err < size)
140
 
                        return err;
141
 
        }
142
 
        offset -= done;
143
 
        if(offset < 0)
144
 
                offset = 0;
145
 
        if(buf->tail > buf->head) {
146
 
                size = buf->head - offset;
147
 
                if(size <= 0)
148
 
                        return 0;
149
 
                err = do_write(sock, buf->data + offset, size);
150
 
                if(err < 0)
151
 
                        err = 0;
152
 
                done += err;
153
 
        }
154
 
        return done;
155
 
}
156
 
 
157
 
void rlbuf_init(struct rl_buffer **buf, int size) {
158
 
        if(!*buf) {
159
 
                *buf = malloc(sizeof(**buf));
160
 
                if (!(*buf))
161
 
                        rl_fatal(EX_SOFTWARE, "ABORT - Can't allocate memory");
162
 
                memset(*buf, 0, sizeof(**buf));
163
 
        } else {
164
 
                (*buf)->head = (*buf)->tail = 0;
165
 
        }
166
 
        if((*buf)->data) {
167
 
                free((*buf)->data);
168
 
                (*buf)->data = NULL;
169
 
        }
170
 
        if(size) {
171
 
                (*buf)->size = size;
172
 
                (*buf)->data = malloc(size);
173
 
                if (!(*buf)->data)
174
 
                        rl_fatal(EX_SOFTWARE, "ABORT - Can't allocate memory");
175
 
        }
176
 
}
177
 
        
178
 
/* vim: set ts=2: */