Subversion Repositories shark

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 pj 1
/*
2
 *   xfermem.c
3
 *
4
 *   Oliver Fromme  <oliver.fromme@heim3.tu-clausthal.de>
5
 *   Sun Apr  6 02:26:26 MET DST 1997
6
 *
7
 *   See xfermem.h for documentation/description.
8
 */
9
 
10
#include <stdio.h>
11
#include <stdlib.h>
12
#include <string.h>
13
#include <unistd.h>
14
#include <errno.h>
15
#include <sys/types.h>
16
#include <sys/time.h>
17
#include <sys/uio.h>
18
#include <sys/mman.h>
19
#include <sys/socket.h>
20
#include <fcntl.h>
21
 
22
#include "xfermem.h"
23
#include "mpg123.h"
24
 
25
#ifndef USE_MMAP
26
#include <sys/ipc.h>
27
#include <sys/shm.h>
28
#endif
29
 
30
extern int errno;
31
 
32
#if defined (USE_MMAP) && defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
33
#define MAP_ANON MAP_ANONYMOUS
34
#endif
35
 
36
void xfermem_init (txfermem **xf, int bufsize, int msize)
37
{
38
        int regsize = bufsize + msize + sizeof(txfermem);
39
 
40
#ifdef USE_MMAP
41
#  ifdef MAP_ANON
42
        if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE,
43
                        MAP_ANON | MAP_SHARED, -1, 0)) == (txfermem *) -1) {
44
                perror ("mmap()");
45
                exit (1);
46
        }
47
#  else
48
        int devzero;
49
        if ((devzero = open("/dev/zero", O_RDWR, 0)) == -1) {
50
                perror ("open(/dev/zero)");
51
                exit (1);
52
        }
53
        if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE,
54
                        MAP_SHARED, devzero, 0)) == (txfermem *) -1) {
55
                perror ("mmap()");
56
                exit (1);
57
        }
58
        close (devzero);
59
#  endif
60
#else
61
        struct shmid_ds shmemds;
62
        int shmemid;
63
        if ((shmemid = shmget(IPC_PRIVATE, regsize, IPC_CREAT | 0600)) == -1) {
64
                perror ("shmget()");
65
                exit (1);
66
        }
67
        if ((*xf = (txfermem *) shmat(shmemid, 0, 0)) == (txfermem *) -1) {
68
                perror ("shmat()");
69
                shmctl (shmemid, IPC_RMID, &shmemds);
70
                exit (1);
71
        }
72
        if (shmctl(shmemid, IPC_RMID, &shmemds) == -1) {
73
                perror ("shmctl()");
74
                xfermem_done (*xf);
75
                exit (1);
76
        }
77
#endif
78
        if (socketpair(AF_UNIX, SOCK_STREAM, 0, (*xf)->fd) < 0) {
79
                perror ("socketpair()");
80
                xfermem_done (*xf);
81
                exit (1);
82
        }
83
        (*xf)->freeindex = (*xf)->readindex = 0;
84
        (*xf)->wakeme[0] = (*xf)->wakeme[1] = FALSE;
85
        (*xf)->data = ((byte *) *xf) + sizeof(txfermem) + msize;
86
        (*xf)->metadata = ((byte *) *xf) + sizeof(txfermem);
87
        (*xf)->size = bufsize;
88
        (*xf)->metasize = msize;
89
}
90
 
91
void xfermem_done (txfermem *xf)
92
{
93
#ifdef USE_MMAP
94
        munmap ((caddr_t) xf, xf->size + xf->metasize + sizeof(txfermem));
95
#else
96
        if (shmdt((void *) xf) == -1) {
97
                perror ("shmdt()");
98
                exit (1);
99
        }
100
#endif
101
}
102
 
103
void xfermem_init_writer (txfermem *xf)
104
{
105
        close (xf->fd[XF_READER]);
106
}
107
 
108
void xfermem_init_reader (txfermem *xf)
109
{
110
        close (xf->fd[XF_WRITER]);
111
}
112
 
113
int xfermem_get_freespace (txfermem *xf)
114
{
115
        int freeindex, readindex;
116
 
117
        if ((freeindex = xf->freeindex) < 0
118
                        || (readindex = xf->readindex) < 0)
119
                return (0);
120
        if (readindex > freeindex)
121
                return ((readindex - freeindex) - 1);
122
        else
123
                return ((xf->size - (freeindex - readindex)) - 1);
124
}
125
 
126
int xfermem_get_usedspace (txfermem *xf)
127
{
128
        int freeindex, readindex;
129
 
130
        if ((freeindex = xf->freeindex) < 0
131
                        || (readindex = xf->readindex) < 0)
132
                return (0);
133
        if (freeindex >= readindex)
134
                return (freeindex - readindex);
135
        else
136
                return (xf->size - (readindex - freeindex));
137
}
138
 
139
int xfermem_write (txfermem *xf, byte *data, int count)
140
{
141
        int nbytes;
142
 
143
        if ((nbytes = xfermem_get_freespace(xf))> count)
144
                nbytes = count;
145
        if (nbytes) {
146
                if (xf->freeindex + nbytes > xf->size) {
147
                        int first = xf->size - xf->freeindex;
148
                        memcpy (xf->data + xf->freeindex, data, first);
149
                        memcpy (xf->data, data + first, nbytes - first);
150
                }
151
                else
152
                        memcpy (xf->data + xf->freeindex, data, nbytes);
153
                xf->freeindex = (xf->freeindex + nbytes) % xf->size;
154
        }
155
        return (nbytes);
156
}
157
 
158
int xfermem_read (txfermem *xf, byte *data, int count)
159
{
160
        int nbytes;
161
 
162
        if ((nbytes = xfermem_get_usedspace(xf))> count)
163
                nbytes = count;
164
        if (nbytes) {
165
                if (xf->readindex + nbytes > xf->size) {
166
                        int first = xf->size - xf->readindex;
167
                        memcpy (data, xf->data + xf->readindex, first);
168
                        memcpy (data + first, xf->data, nbytes - first);
169
                }
170
                else
171
                        memcpy (data, xf->data + xf->readindex, nbytes);
172
                xf->readindex = (xf->readindex + nbytes) % xf->size;
173
        }
174
        return (nbytes);
175
}
176
 
177
int xfermem_getcmd (int fd, int block)
178
{
179
        fd_set selfds;
180
        struct timeval selto = {0, 0};
181
        byte cmd;
182
 
183
        for (;;) {
184
                FD_ZERO (&selfds);
185
                FD_SET (fd, &selfds);
186
                switch (select(FD_SETSIZE, &selfds, NULL, NULL, block ? NULL : &selto)) {
187
                        case 0:
188
                                if (!block)
189
                                        return (0);
190
                                continue;
191
                        case -1:
192
                                if (errno == EINTR)
193
                                        continue;
194
                                return (-2);
195
                        case 1:
196
                                if (FD_ISSET(fd, &selfds))
197
                                        switch (read(fd, &cmd, 1)) {
198
                                                case 0: /* EOF */
199
                                                        return (-1);
200
                                                case -1:
201
                                                        if (errno == EINTR)
202
                                                                continue;
203
                                                        return (-3);
204
                                                case 1:
205
                                                        return (cmd);
206
                                                default: /* ?!? */
207
                                                        return (-4);
208
                                        }
209
                                else /* ?!? */
210
                                        return (-5);
211
                        default: /* ?!? */
212
                                return (-6);
213
                }
214
        }
215
}
216
 
217
int xfermem_putcmd (int fd, byte cmd)
218
{
219
        for (;;)
220
                switch (write(fd, &cmd, 1)) {
221
                        case 1:
222
                                return (1);
223
                        case -1:
224
                                if (errno != EINTR)
225
                                        return (-1);
226
                }
227
}
228
 
229
int xfermem_block (int readwrite, txfermem *xf)
230
{
231
        int myfd = xf->fd[readwrite];
232
        int result;
233
 
234
        xf->wakeme[readwrite] = TRUE;
235
        if (xf->wakeme[1 - readwrite])
236
                xfermem_putcmd (myfd, XF_CMD_WAKEUP);
237
        result = xfermem_getcmd(myfd, TRUE);
238
        xf->wakeme[readwrite] = FALSE;
239
        return ((result <= 0) ? -1 : result);
240
}
241
 
242
/* EOF */