source: titan/titan/provider.h @ 23980

Last change on this file since 23980 was 23980, checked in by nit, 9 years ago

[titan] fix provider sort

File size: 8.7 KB
Line 
1#ifndef PROVIDER_H
2#define PROVIDER_H
3
4int getlastproviderid()
5{
6        int lastid = 0;
7        struct provider *node = provider, *prev = NULL;
8
9        while(node != NULL)
10        {
11                if(lastid < node->providerid)
12                        lastid = node->providerid;
13                prev = node;
14                node = node->next;
15        }
16
17        return lastid;
18}
19
20struct provider* getlastprovider(struct provider* node)
21{
22        struct provider *prev = NULL;
23
24        while(node != NULL)
25        {
26                prev = node;
27                node = node->next;
28        }
29
30        return prev;
31}
32
33int moveproviderblockdown(struct provider* node)
34{
35        int i = 0, ret = 0;
36        struct provider* prev = NULL;
37
38        if(node == NULL)
39        {
40                err("NULL detect");
41                return 1;
42        }
43
44        for(i = 0; i < status.moveblockcount; i++)
45        {
46                if(node == NULL) break;
47                node = node->next;
48        }
49
50        for(i = 0; i < status.moveblockcount + 1; i++)
51        {
52                if(node == NULL) break;
53                prev = node->prev;
54                ret = moveproviderdown(node);
55                node = prev;
56        }
57
58        return ret;
59}
60
61int moveproviderdown(struct provider* node)
62{
63        struct provider* prev = NULL, *next = NULL;
64
65        if(node == NULL || provider == NULL)
66        {
67                err("NULL detect");
68                return 1;
69        }
70       
71        //only one node
72        if(node->prev == NULL && node->next == NULL)
73                return 0;
74
75        //last node
76        if(node->next == NULL)
77        {
78                if(node->prev != NULL)
79                        node->prev->next = NULL;
80                node->prev = NULL;
81                node->next = provider;
82                provider->prev = node;
83                provider = node;
84                return 99;
85        }
86
87        //haenge node aus
88        if(node->prev != NULL)
89                node->prev->next = node->next;
90        else
91                provider = node->next;
92        node->next->prev = node->prev;
93
94        //save nodes next and prev
95        next = node->next;
96        prev = node->prev;
97
98        //haenge es eine pos nacher ein
99        node->next = next->next;
100        node->prev = next;
101       
102        if(next->next != NULL)
103                next->next->prev = node;
104        next->next = node;
105
106        status.writeprovider = 1;
107        return 0;
108}
109
110int moveproviderblockup(struct provider* node)
111{
112        int i = 0, ret = 0;
113        struct provider* next = NULL;
114
115        if(node == NULL)
116        {
117                err("NULL detect");
118                return 1;
119        }
120
121        for(i = 0; i < status.moveblockcount + 1; i++)
122        {
123                if(node == NULL) break;
124                next = node->next;
125                ret = moveproviderup(node);
126                node = next;
127        }
128
129        return ret;
130}
131
132int moveproviderup(struct provider* node)
133{
134        struct provider* prev = NULL, *next = NULL, *last = NULL;
135
136        if(node == NULL || provider == NULL)
137        {
138                err("NULL detect");
139                return 1;
140        }
141       
142        //only one node
143        if(node->prev == NULL && node->next == NULL)
144                return 0;
145
146        //first node
147        if(node->prev == NULL)
148        {
149                last = getlastprovider(provider);
150
151                if(node->next != NULL)
152                        node->next->prev = NULL;
153                provider = node->next;
154                node->next = NULL;
155                last->next = node;
156                node->prev = last;
157                return 99;
158        }
159
160        //haenge node aus
161        node->prev->next = node->next;
162        if(node->next != NULL)
163                node->next->prev = node->prev;
164
165        //save nodes next and prev
166        next = node->next;
167        prev = node->prev;
168
169        //haenge es eine pos voher ein
170        node->next = prev;
171        node->prev = prev->prev;
172       
173        if(prev->prev != NULL)
174                prev->prev->next = node;
175        else
176                provider = node;
177        prev->prev = node;
178
179        status.writeprovider = 1;
180        return 0;
181}
182
183struct provider* addprovider(char *line, int count, struct provider* last)
184{
185        struct provider *newnode = NULL, *prev = NULL, *node = provider;
186        char *name = NULL;
187        int ret = 0;
188
189        newnode = (struct provider*)calloc(1, sizeof(struct provider));
190        if(newnode == NULL)
191        {
192                err("no memory");
193                return NULL;
194        }
195
196        name = malloc(MINMALLOC);
197        if(name == NULL)
198        {
199                err("no memory");
200                free(newnode);
201                return NULL;
202        }
203
204        status.writeprovider = 1;
205
206        ret = sscanf(line, "%d#%[^#]#%d", &newnode->providerid, name, &newnode->flag);
207        if(ret != 3)
208        {
209                if(count > 0)
210                {
211                        err("providerlist line %d not ok", count);
212                }
213                else
214                {
215                        err("add provider");
216                }
217                free(name);
218                free(newnode);
219                return NULL;
220        }
221
222        newnode->name = ostrshrink(name);
223
224        if(last == NULL)
225        {
226                while(node != NULL && strcasecmp(newnode->name, node->name) > 0)
227                {
228                        prev = node;
229                        node = node->next;
230                }
231        }
232        else
233        {
234                prev = last;
235                node = last->next;
236        }
237
238        if(prev == NULL)
239                provider = newnode;
240        else
241        {
242                prev->next = newnode;
243                newnode->prev = prev;
244        }
245        newnode->next = node;
246        if(node != NULL) node->prev = newnode;
247
248        return newnode;
249}
250
251int readprovider(const char* filename)
252{
253        FILE *fd = NULL;
254        char *fileline = NULL, *tmpstr = NULL, *tmpstr0 = NULL, *tmpstr1 = NULL;
255        int linecount = 0, treffer0 = 1, treffer1 = 1, len = 0;
256        struct provider* last = NULL, *tmplast = NULL;
257       
258        tmpstr0 = getconfig("channellist", NULL);
259        tmpstr1 = getconfig("rchannellist", NULL);
260        if(ostrncmp("(PROVIDER)-", tmpstr0, 11) == 0) treffer0 = 0;
261        if(ostrncmp("(PROVIDER)-", tmpstr1, 11) == 0) treffer1 = 0;
262
263        fileline = malloc(MINMALLOC);
264        if(fileline == NULL)
265        {
266                err("no memory");
267                return 1;
268        }
269
270        fd = fopen(filename, "r");
271        if(fd == NULL)
272        {
273                perr("can't open %s", filename);
274                free(fileline);
275                return 1;
276        }
277
278        while(fgets(fileline, MINMALLOC, fd) != NULL)
279        {
280                if(fileline[0] == '#' || fileline[0] == '\n')
281                        continue;
282                len = strlen(fileline) - 1;
283                if(len >= 0 && fileline[len] == '\n')
284                        fileline[len] = '\0';
285                len--;
286                if(len >= 0 && fileline[len] == '\r')
287                        fileline[len] = '\0';
288
289                linecount++;
290
291                if(last == NULL) last = tmplast;
292                last = addprovider(fileline, linecount, last);
293                if(last != NULL)
294                {
295                        tmplast = last;
296                        tmpstr = ostrcat("(PROVIDER)-", last->name, 0, 0);
297
298                        if(treffer0 == 0 && ostrcmp(tmpstr, tmpstr0) == 0)
299                                treffer0 = 1;
300                        if(treffer1 == 0 && ostrcmp(tmpstr, tmpstr1) == 0)
301                                treffer1 = 1;
302                        free(tmpstr); tmpstr = NULL;
303                }
304        }
305       
306        if(treffer0 == 0) delconfig("channellist");
307        if(treffer1 == 0) delconfig("rchannellist");
308
309        status.writeprovider = 0;
310        free(fileline);
311        fclose(fd);
312        return 0;
313}
314
315void delprovider(int providerid)
316{
317        struct provider *node = provider, *prev = provider;
318
319        while(node != NULL)
320        {
321                if(node->providerid == providerid)
322                {
323                        status.writeprovider = 1;
324                        if(node == provider)
325                        {
326                                provider = node->next;
327                                if(provider != NULL)
328                                        provider->prev = NULL;
329                        }
330                        else
331                        {
332                                prev->next = node->next;
333                                if(node->next != NULL)
334                                        node->next->prev = prev;
335                        }
336
337                        free(node->name);
338                        node->name = NULL;
339
340                        free(node);
341                        node = NULL;
342                        break;
343                }
344
345                prev = node;
346                node = node->next;
347        }
348}
349
350void delprovidernotused(struct provider* node)
351{
352        struct channel* chnode = channel;
353
354        if(node == NULL) return;
355
356        while(chnode != NULL)
357        {
358                if(chnode->providerid == node->providerid)
359                        return;
360                chnode = chnode->next;
361        }
362        delprovider(node->providerid);
363}
364
365struct provider* getproviderbyname(char* name)
366{
367        struct provider *node = provider;
368
369        while(node != NULL)
370        {
371                if(ostrcmp(node->name, name) == 0)
372                        return node;
373
374                node = node->next;
375        }
376        debug(100, "provider not found (name=%s)", name);
377        return NULL;
378}
379
380struct provider* getprovider(int providerid)
381{
382        struct provider *node = provider;
383
384        while(node != NULL)
385        {
386                if(node->providerid == providerid)
387                        return node;
388
389                node = node->next;
390        }
391        debug(100, "provider not found (providerid=%d)", providerid);
392        return NULL;
393}
394
395int provider2bouquet(int providerid)
396{
397        struct provider* pnode = NULL;
398        struct mainbouquet* mnode = NULL;
399        struct channel* chnode = channel;
400        char* tmpstr = NULL;
401        char* path = NULL;
402       
403        pnode = getprovider(providerid);
404        if(pnode == NULL) return 1;
405
406        tmpstr = ostrcat(tmpstr, pnode->name, 1, 0);
407        tmpstr = ostrcat(tmpstr, "#", 1, 0);
408        tmpstr = ostrcat(tmpstr, oitoa(status.servicetype), 1, 1);
409        tmpstr = ostrcat(tmpstr, "#", 1, 0);
410
411        path = realpath(getconfig("bouquetfile", NULL), NULL);
412        if(path != NULL)
413        {
414                path = dirname(path);
415                path = ostrcat(path, "/bouquets.", 1, 0);
416                                       
417                path = ostrcat(path, pnode->name, 1, 0);
418                if(status.servicetype == 0) path = ostrcat(path, "_tv", 1, 0);
419                if(status.servicetype == 1) path = ostrcat(path, "_radio", 1, 0);
420
421                if(file_exist(path))
422                {
423                        free(tmpstr); tmpstr = NULL;
424                        free(path); path = NULL;
425                        return 1;
426                }
427
428                tmpstr = ostrcat(tmpstr, path, 1, 0);
429                mnode = addmainbouquet(tmpstr, 1, NULL);
430        }
431        free(tmpstr); tmpstr = NULL;
432        free(path); path = NULL;
433
434        if(mnode != NULL)
435        {
436                while(chnode != NULL)
437                {
438                        if(chnode->providerid == providerid && chnode->servicetype == status.servicetype)
439                        {
440                                tmpstr = ostrcat(tmpstr, oitoa(chnode->serviceid), 1, 1);
441                                tmpstr = ostrcat(tmpstr, "#", 1, 0);
442                                tmpstr = ostrcat(tmpstr, ollutoa(chnode->transponderid), 1, 1);
443                                addbouquet(&mnode->bouquet, tmpstr, status.servicetype, 1, NULL);
444                                free(tmpstr); tmpstr = NULL;
445                        }
446                        chnode = chnode->next;
447                }
448        }
449
450        return 0;
451}
452
453void freeprovider()
454{
455        struct provider *node = provider, *prev = provider;
456
457        while(node != NULL)
458        {
459                prev = node;
460                node = node->next;
461                if(prev != NULL)
462                        delprovider(prev->providerid);
463        }
464}
465
466int writeprovider(const char *filename)
467{
468        FILE *fd = NULL;
469        struct provider *node = provider;
470        int ret;
471
472        fd = fopen(filename, "w");
473        if(fd == NULL)
474        {
475                perr("can't open %s", filename);
476                return 1;
477        }
478
479        while(node != NULL)
480        {
481                ret = fprintf(fd, "%d#%s#%d\n", node->providerid, node->name, node->flag);
482                if(ret < 0)
483                {
484                        perr("writting file %s", filename);
485                }
486                node = node->next;
487        }
488
489        fclose(fd);
490        return 0;
491}
492
493#endif
494
Note: See TracBrowser for help on using the repository browser.