source: titan/titan/provider.h @ 31136

Last change on this file since 31136 was 30465, checked in by obi, 10 years ago

add provider sort
File size: 10.8 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
395//flag 0: add all provider
396//flag 1: add only provider with channel
397int provider2bouquet(int providerid, int flag)
398{
399        int treffer = 0;
400        struct provider* pnode = NULL;
401        struct mainbouquet* mnode = NULL;
402        struct channel* chnode = channel;
403        char* tmpstr = NULL;
404        char* path = NULL;
405       
406        pnode = getprovider(providerid);
407        if(pnode == NULL) return 1;
408
409        tmpstr = ostrcat(tmpstr, pnode->name, 1, 0);
410        tmpstr = ostrcat(tmpstr, "#", 1, 0);
411        tmpstr = ostrcat(tmpstr, oitoa(status.servicetype), 1, 1);
412        tmpstr = ostrcat(tmpstr, "#", 1, 0);
413
414        path = realpath(getconfig("bouquetfile", NULL), NULL);
415        if(path != NULL)
416        {
417                path = dirname(path);
418                path = ostrcat(path, "/bouquets.", 1, 0);
419                                       
420                path = ostrcat(path, pnode->name, 1, 0);
421                if(status.servicetype == 0) path = ostrcat(path, "_tv", 1, 0);
422                if(status.servicetype == 1) path = ostrcat(path, "_radio", 1, 0);
423
424                if(file_exist(path))
425                {
426                        free(tmpstr); tmpstr = NULL;
427                        free(path); path = NULL;
428                        return 1;
429                }
430
431                tmpstr = ostrcat(tmpstr, path, 1, 0);
432                mnode = addmainbouquet(tmpstr, 1, NULL);
433        }
434        free(tmpstr); tmpstr = NULL;
435
436        if(mnode != NULL)
437        {
438                while(chnode != NULL)
439                {
440                        if(chnode->providerid == providerid && chnode->servicetype == status.servicetype)
441                        {
442                                tmpstr = ostrcat(tmpstr, oitoa(chnode->serviceid), 1, 1);
443                                tmpstr = ostrcat(tmpstr, "#", 1, 0);
444                                tmpstr = ostrcat(tmpstr, ollutoa(chnode->transponderid), 1, 1);
445                                treffer = 1;
446                                addbouquet(&mnode->bouquet, tmpstr, status.servicetype, 1, NULL);
447                                free(tmpstr); tmpstr = NULL;
448                        }
449                        chnode = chnode->next;
450                }
451        }
452       
453        if(treffer == 0 && flag == 1)
454                delmainbouquet(path, 1);
455 
456        free(path); path = NULL;
457        return 0;
458}
459
460void freeprovider()
461{
462        struct provider *node = provider, *prev = provider;
463
464        while(node != NULL)
465        {
466                prev = node;
467                node = node->next;
468                if(prev != NULL)
469                        delprovider(prev->providerid);
470        }
471}
472
473struct provider* sortprovider()
474{
475        struct provider* tmpnode[10] = {0};
476        struct provider* node = provider, *tnode = NULL;
477        struct provider *next = NULL, *prev = NULL;
478        struct provider **tnodeaddr = NULL;
479       
480        if(node == NULL) return NULL;
481
482        while(node != NULL)
483        {
484                next = node->next;
485                prev = NULL;
486
487                if(strcasecmp("c", node->name) > 0) {tnode = tmpnode[0]; tnodeaddr = &tmpnode[0];}
488                else if(strcasecmp("f", node->name) > 0) {tnode = tmpnode[1]; tnodeaddr = &tmpnode[1];}
489                else if(strcasecmp("i", node->name) > 0) {tnode = tmpnode[2]; tnodeaddr = &tmpnode[2];}
490                else if(strcasecmp("l", node->name) > 0) {tnode = tmpnode[3]; tnodeaddr = &tmpnode[3];}
491                else if(strcasecmp("o", node->name) > 0) {tnode = tmpnode[4]; tnodeaddr = &tmpnode[4];}
492                else if(strcasecmp("r", node->name) > 0) {tnode = tmpnode[5]; tnodeaddr = &tmpnode[5];}
493                else if(strcasecmp("u", node->name) > 0) {tnode = tmpnode[6]; tnodeaddr = &tmpnode[6];}
494                else if(strcasecmp("x", node->name) > 0) {tnode = tmpnode[7]; tnodeaddr = &tmpnode[7];}
495                else if(strcasecmp("z", node->name) > 0) {tnode = tmpnode[8]; tnodeaddr = &tmpnode[8];}
496                else {tnode = tmpnode[9]; tnodeaddr = &tmpnode[9];}
497
498                while(tnode != NULL && strcasecmp(node->name, tnode->name) > 0)
499                {
500                        prev = tnode;
501                        tnode = tnode->next;
502                }
503
504                if(prev == NULL)
505                {
506                        *tnodeaddr = node;
507                        node->prev = NULL;
508                }
509                else
510                {
511                        prev->next = node;
512                        node->prev = prev;
513                }
514                node->next = tnode;
515                if(tnode != NULL) tnode->prev = node;
516
517                node = next;
518        }
519
520        int i = 0, first = 0;
521        prev = NULL; node = NULL;
522        for(i = 0; i < 10; i++)
523        {
524                if(tmpnode[i] != NULL)
525                {
526                        if(prev != NULL)
527                        {
528                                prev->next = tmpnode[i];
529                                tmpnode[i]->prev = prev;
530                        }
531
532                        if(first == 0)
533                        {
534                                provider = tmpnode[i];
535                                first = 1;
536                        }
537
538                        node = tmpnode[i];
539                        while(node != NULL)
540                        {
541                                prev = node;
542                                node = node->next;
543                        }
544                }
545        }
546
547        status.writeprovider = 1;
548        return provider;
549}
550
551int writeprovider(const char *filename)
552{
553        FILE *fd = NULL;
554        struct provider *node = provider;
555        int ret;
556
557        fd = fopen(filename, "w");
558        if(fd == NULL)
559        {
560                perr("can't open %s", filename);
561                return 1;
562        }
563
564        while(node != NULL)
565        {
566                ret = fprintf(fd, "%d#%s#%d\n", node->providerid, node->name, node->flag);
567                if(ret < 0)
568                {
569                        perr("writting file %s", filename);
570                }
571                node = node->next;
572        }
573
574        fclose(fd);
575        return 0;
576}
577
578#endif
579
Note: See TracBrowser for help on using the repository browser.