CPPMyth
Library to interoperate with MythTV server
Loading...
Searching...
No Matches
mythprotomonitor.cpp
1/*
2 * Copyright (C) 2014 Jean-Luc Barriere
3 *
4 * This Program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2, or (at your option)
7 * any later version.
8 *
9 * This Program 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
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; see the file COPYING. If not, write to
16 * the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
17 * MA 02110-1301 USA
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 */
21
22#include "mythprotomonitor.h"
23#include "mythprotorecorder.h"
24#include "../private/debug.h"
25#include "../private/socket.h"
26#include "../private/os/threads/latch.h"
27#include "../private/builtin.h"
28
29#include <limits>
30#include <cstdio>
31
32using namespace Myth;
33
38
39ProtoMonitor::ProtoMonitor(const std::string& server, unsigned port)
40: ProtoBase(server, port)
41, m_frontend(false)
42{
43}
44
45ProtoMonitor::ProtoMonitor(const std::string& server, unsigned port, bool frontend)
46: ProtoBase(server, port)
47, m_frontend(frontend)
48{
49}
50
51bool ProtoMonitor::Open()
52{
53 bool ok = false;
54
55 if (!OpenConnection(PROTO_MONITOR_RCVBUF))
56 return false;
57
58 if (m_protoVersion >= 88)
59 ok = Announce88();
60 else
61 ok = Announce75();
62
63 if (ok)
64 {
65 return true;
66 }
67 Close();
68 return false;
69}
70
71void ProtoMonitor::Close()
72{
73 ProtoBase::Close();
74 // Clean hanging and disable retry
75 m_tainted = m_hang = false;
76}
77
78bool ProtoMonitor::IsOpen()
79{
80 // Try reconnect
81 if (m_hang)
82 return ProtoMonitor::Open();
83 return ProtoBase::IsOpen();
84}
85
86bool ProtoMonitor::Announce75()
87{
88 OS::WriteLock lock(*m_latch);
89
90 std::string cmd("ANN Monitor ");
91 cmd.append(m_socket->GetMyHostName()).append(" 0");
92 if (!SendCommand(cmd.c_str()))
93 return false;
94
95 std::string field;
96 if (!ReadField(field) || !IsMessageOK(field))
97 goto out;
98 return true;
99
100out:
101 FlushMessage();
102 return false;
103}
104
105bool ProtoMonitor::Announce88()
106{
107 OS::WriteLock lock(*m_latch);
108
109 std::string cmd((m_frontend ? "ANN Frontend " : "ANN Monitor "));
110 cmd.append(m_socket->GetMyHostName()).append(" 0");
111 if (!SendCommand(cmd.c_str()))
112 return false;
113
114 std::string field;
115 if (!ReadField(field) || !IsMessageOK(field))
116 goto out;
117 return true;
118
119out:
120 FlushMessage();
121 return false;
122}
123
124ProtoRecorderPtr ProtoMonitor::GetRecorderFromNum75(int rnum)
125{
126 BUILTIN_BUFFER buf;
127 std::string field;
128 ProtoRecorderPtr recorder;
129 std::string hostname;
130 uint16_t port;
131
132 OS::WriteLock lock(*m_latch);
133 if (!IsOpen())
134 return recorder;
135 std::string cmd("GET_RECORDER_FROM_NUM");
136 cmd.append(PROTO_STR_SEPARATOR);
137 int32_to_string((int32_t)rnum, &buf);
138 cmd.append(buf.data);
139
140 if (!SendCommand(cmd.c_str()))
141 return recorder;
142
143 if (!ReadField(hostname) || hostname == "nohost")
144 goto out;
145 if (!ReadField(field) || string_to_uint16(field.c_str(), &port))
146 goto out;
147 FlushMessage();
148 DBG(DBG_DEBUG, "%s: open recorder %d (%s:%u)\n", __FUNCTION__, (int)rnum, hostname.c_str(), (unsigned)port);
149 recorder.reset(new ProtoRecorder(rnum, hostname, port));
150 return recorder;
151out:
152 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
153 FlushMessage();
154 return recorder;
155}
156
157bool ProtoMonitor::QueryFreeSpaceSummary75(int64_t *total, int64_t *used)
158{
159 std::string field;
160
161 OS::WriteLock lock(*m_latch);
162 if (!IsOpen())
163 return false;
164 std::string cmd("QUERY_FREE_SPACE_SUMMARY");
165
166 if (!SendCommand(cmd.c_str()))
167 return false;
168
169 if (!ReadField(field) || string_to_int64(field.c_str(), total))
170 goto out;
171 if (!ReadField(field) || string_to_int64(field.c_str(), used))
172 goto out;
173 FlushMessage();
174 return true;
175out:
176 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
177 FlushMessage();
178 return false;
179}
180
181std::string ProtoMonitor::GetSetting75(const std::string& hostname, const std::string& setting)
182{
183 std::string field;
184
185 OS::WriteLock lock(*m_latch);
186 if (!IsOpen())
187 return field;
188 std::string cmd("QUERY_SETTING ");
189 cmd.append(hostname).append(" ").append(setting);
190
191 if (!SendCommand(cmd.c_str()))
192 return field;
193
194 if (!ReadField(field))
195 goto out;
196 FlushMessage();
197 return field;
198out:
199 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
200 FlushMessage();
201 field.clear();
202 return field;
203}
204
205bool ProtoMonitor::SetSetting75(const std::string& hostname, const std::string& setting, const std::string& value)
206{
207 std::string field;
208
209 OS::WriteLock lock(*m_latch);
210 if (!IsOpen())
211 return false;
212 std::string cmd("SET_SETTING ");
213 cmd.append(hostname).append(" ").append(setting).append(" ").append(value);
214
215 if (!SendCommand(cmd.c_str()))
216 return false;
217
218 if (!ReadField(field) || !IsMessageOK(field))
219 goto out;
220 FlushMessage();
221 return true;
222out:
223 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
224 FlushMessage();
225 return false;
226}
227
228bool ProtoMonitor::QueryGenpixmap75(const Program& program)
229{
230 std::string field;
231
232 OS::WriteLock lock(*m_latch);
233 if (!IsOpen())
234 return false;
235 std::string cmd("QUERY_GENPIXMAP2");
236 cmd.append(PROTO_STR_SEPARATOR).append("do_not_care").append(PROTO_STR_SEPARATOR);
237 MakeProgramInfo(program, field);
238 cmd.append(field);
239
240 if (!SendCommand(cmd.c_str()))
241 return false;
242
243 if (!ReadField(field) || !IsMessageOK(field))
244 goto out;
245 FlushMessage();
246 return true;
247out:
248 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
249 FlushMessage();
250 return false;
251}
252
253bool ProtoMonitor::DeleteRecording75(const Program& program, bool force, bool forget)
254{
255 BUILTIN_BUFFER buf;
256 std::string field;
257
258 OS::WriteLock lock(*m_latch);
259 if (!IsOpen())
260 return false;
261 std::string cmd("DELETE_RECORDING ");
262 uint32_to_string(program.channel.chanId, &buf);
263 cmd.append(buf.data).append(" ");
264 time_to_iso8601utc(program.recording.startTs, &buf);
265 cmd.append(buf.data).append(" ");
266 if (force)
267 cmd.append("FORCE ");
268 else
269 cmd.append("NO_FORCE ");
270 if (forget)
271 cmd.append("FORGET");
272 else
273 cmd.append("NO_FORGET");
274
275 if (!SendCommand(cmd.c_str()))
276 return false;
277
278 if (!ReadField(field))
279 goto out;
280 DBG(DBG_DEBUG, "%s: succeeded (%s)\n", __FUNCTION__, program.fileName.c_str());
281 return true;
282 out:
283 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
284 FlushMessage();
285 return false;
286}
287
288bool ProtoMonitor::UndeleteRecording75(const Program& program)
289{
290 std::string field;
291
292 OS::WriteLock lock(*m_latch);
293 if (!IsOpen())
294 return false;
295 std::string cmd("UNDELETE_RECORDING");
296 cmd.append(PROTO_STR_SEPARATOR);
297 MakeProgramInfo(program, field);
298 cmd.append(field);
299
300 if (!SendCommand(cmd.c_str()))
301 return false;
302
303 if (!ReadField(field) || field != "0")
304 goto out;
305 DBG(DBG_DEBUG, "%s: succeeded (%s)\n", __FUNCTION__, program.fileName.c_str());
306 return true;
307 out:
308 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
309 FlushMessage();
310 return false;
311}
312
313bool ProtoMonitor::StopRecording75(const Program& program)
314{
315 std::string field;
316 int32_t num;
317
318 OS::WriteLock lock(*m_latch);
319 if (!IsOpen())
320 return false;
321 std::string cmd("STOP_RECORDING");
322 cmd.append(PROTO_STR_SEPARATOR);
323 MakeProgramInfo(program, field);
324 cmd.append(field);
325
326 if (!SendCommand(cmd.c_str()))
327 return false;
328
329 if (!ReadField(field) || string_to_int32(field.c_str(), &num) || num < 0)
330 goto out;
331 DBG(DBG_DEBUG, "%s: succeeded (%s)\n", __FUNCTION__, program.fileName.c_str());
332 return true;
333 out:
334 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
335 FlushMessage();
336 return false;
337}
338
339bool ProtoMonitor::CancelNextRecording75(int rnum, bool cancel)
340{
341 BUILTIN_BUFFER buf;
342 std::string field;
343
344 OS::WriteLock lock(*m_latch);
345 if (!IsOpen())
346 return false;
347 std::string cmd("QUERY_RECORDER ");
348 int32_to_string(rnum, &buf);
349 cmd.append(buf.data).append(PROTO_STR_SEPARATOR);
350 cmd.append("CANCEL_NEXT_RECORDING").append(PROTO_STR_SEPARATOR);
351 cmd.append((cancel ? "1" : "0"));
352
353 if (!SendCommand(cmd.c_str()))
354 return false;
355
356 if (!ReadField(field) || !IsMessageOK(field))
357 goto out;
358 DBG(DBG_DEBUG, "%s: succeeded\n", __FUNCTION__);
359 return true;
360 out:
361 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
362 FlushMessage();
363 return false;
364}
365
366StorageGroupFilePtr ProtoMonitor::QuerySGFile75(const std::string& hostname, const std::string& sgname, const std::string& filename)
367{
368 std::string field;
369 int64_t tmpi;
370 StorageGroupFilePtr sgfile;
371
372 OS::WriteLock lock(*m_latch);
373 if (!IsOpen())
374 return sgfile;
375 std::string cmd("QUERY_SG_FILEQUERY");
376 cmd.append(PROTO_STR_SEPARATOR);
377 cmd.append(hostname).append(PROTO_STR_SEPARATOR);
378 cmd.append(sgname).append(PROTO_STR_SEPARATOR);
379 cmd.append(filename);
380
381 if (!SendCommand(cmd.c_str()))
382 return sgfile;
383 sgfile.reset(new StorageGroupFile());
384
385 if (!ReadField(sgfile->fileName))
386 goto out;
387 if (!ReadField(field) || string_to_int64(field.c_str(), &tmpi))
388 goto out;
389 sgfile->lastModified = (time_t)tmpi;
390 if (!ReadField(field) || string_to_int64(field.c_str(), &(sgfile->size)))
391 goto out;
392 sgfile->hostName = hostname;
393 sgfile->storageGroup = sgname;
394
395 DBG(DBG_DEBUG, "%s: succeeded (%s)\n", __FUNCTION__, sgfile->fileName.c_str());
396 return sgfile;
397 out:
398 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
399 FlushMessage();
400 sgfile.reset();
401 return sgfile;
402}
403
404MarkListPtr ProtoMonitor::GetCutList75(const Program& program)
405{
406 BUILTIN_BUFFER buf;
407 std::string field;
408 int32_t nb;
409 MarkListPtr list(new MarkList);
410
411 OS::WriteLock lock(*m_latch);
412 if (!IsOpen())
413 return list;
414 std::string cmd("QUERY_CUTLIST ");
415 uint32_to_string(program.channel.chanId, &buf);
416 cmd.append(buf.data).append(" ");
417 int64_to_string(program.recording.startTs, &buf);
418 cmd.append(buf.data);
419
420 if (!SendCommand(cmd.c_str()))
421 return list;
422
423 if (!ReadField(field) || string_to_int32(field.c_str(), &nb))
424 goto out;
425 if (nb > 0)
426 {
427 list->reserve(nb);
428 do
429 {
430 MarkPtr mark = MarkPtr(new Mark());
431 if (!ReadField(field) || string_to_int8(field.c_str(), (int8_t*)&(mark->markType)))
432 break;
433 if (!ReadField(field) || string_to_int64(field.c_str(), &(mark->markValue)))
434 break;
435 list->push_back(mark);
436 }
437 while (--nb > 0);
438 }
439 DBG(DBG_DEBUG, "%s: succeeded (%s)\n", __FUNCTION__, program.fileName.c_str());
440 return list;
441 out:
442 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
443 FlushMessage();
444 return list;
445}
446
447MarkListPtr ProtoMonitor::GetCommBreakList75(const Program& program)
448{
449 BUILTIN_BUFFER buf;
450 std::string field;
451 int32_t nb;
452 MarkListPtr list(new MarkList);
453
454 OS::WriteLock lock(*m_latch);
455 if (!IsOpen())
456 return list;
457 std::string cmd("QUERY_COMMBREAK ");
458 uint32_to_string(program.channel.chanId, &buf);
459 cmd.append(buf.data).append(" ");
460 int64_to_string(program.recording.startTs, &buf);
461 cmd.append(buf.data);
462
463 if (!SendCommand(cmd.c_str()))
464 return list;
465
466 if (!ReadField(field) || string_to_int32(field.c_str(), &nb))
467 goto out;
468 if (nb > 0)
469 {
470 list->reserve(nb);
471 do
472 {
473 MarkPtr mark = MarkPtr(new Mark());
474 if (!ReadField(field) || string_to_int8(field.c_str(), (int8_t*)&(mark->markType)))
475 break;
476 if (!ReadField(field) || string_to_int64(field.c_str(), &(mark->markValue)))
477 break;
478 list->push_back(mark);
479 }
480 while (--nb > 0);
481 }
482 DBG(DBG_DEBUG, "%s: succeeded (%s)\n", __FUNCTION__, program.fileName.c_str());
483 return list;
484 out:
485 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
486 FlushMessage();
487 return list;
488}
489
490bool ProtoMonitor::BlockShutdown75()
491{
492 std::string field;
493
494 OS::WriteLock lock(*m_latch);
495 if (!IsOpen())
496 return false;
497 std::string cmd("BLOCK_SHUTDOWN");
498
499 if (!SendCommand(cmd.c_str()))
500 return false;
501
502 if (!ReadField(field) || !IsMessageOK(field))
503 goto out;
504 DBG(DBG_DEBUG, "%s: succeeded\n", __FUNCTION__);
505 return true;
506 out:
507 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
508 FlushMessage();
509 return false;
510}
511
512bool ProtoMonitor::AllowShutdown75()
513{
514 std::string field;
515
516 OS::WriteLock lock(*m_latch);
517 if (!IsOpen())
518 return false;
519 std::string cmd("ALLOW_SHUTDOWN");
520
521 if (!SendCommand(cmd.c_str()))
522 return false;
523
524 if (!ReadField(field) || !IsMessageOK(field))
525 goto out;
526 DBG(DBG_DEBUG, "%s: succeeded\n", __FUNCTION__);
527 return true;
528 out:
529 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
530 FlushMessage();
531 return false;
532}
533
534std::vector<int> ProtoMonitor::GetFreeCardIdList75()
535{
536 std::string field;
537 std::vector<int> ids;
538 int32_t rnum;
539
540 OS::WriteLock lock(*m_latch);
541 if (!IsOpen())
542 return ids;
543 std::string cmd("GET_FREE_RECORDER_LIST");
544
545 if (!SendCommand(cmd.c_str()))
546 return ids;
547
548 while (m_msgConsumed < m_msgLength)
549 {
550 if (!ReadField(field) || string_to_int32(field.c_str(), &rnum))
551 {
552 DBG(DBG_ERROR, "%s: failed\n", __FUNCTION__);
553 FlushMessage();
554 ids.clear();
555 return ids;
556 }
557 if (rnum > 0)
558 ids.push_back(rnum);
559 }
560 DBG(DBG_DEBUG, "%s: succeeded (%u)\n", __FUNCTION__, (unsigned)ids.size());
561 return ids;
562}
563
564CardInputListPtr ProtoMonitor::GetFreeInputs75()
565{
566 CardInputListPtr list = CardInputListPtr(new CardInputList());
567 std::vector<int> cardList = GetFreeCardIdList75();
568 for (std::vector<int>::const_iterator cardIt = cardList.begin(); cardIt != cardList.end(); ++cardIt)
569 {
570 bool succeeded = false;
571 BUILTIN_BUFFER buf;
572 std::string field;
573
574 OS::WriteLock lock(*m_latch);
575 if (!IsOpen())
576 break;
577 std::string cmd("QUERY_RECORDER ");
578 int32_to_string((int32_t)(*cardIt), &buf);
579 cmd.append(buf.data);
580 cmd.append(PROTO_STR_SEPARATOR);
581 cmd.append("GET_FREE_INPUTS");
582
583 if (!SendCommand(cmd.c_str()))
584 break;
585
586 while (m_msgConsumed < m_msgLength)
587 {
588 CardInputPtr input(new CardInput());
589 if (!ReadField(input->inputName))
590 break;
591 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->sourceId)))
592 break;
593 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->inputId)))
594 break;
595 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->cardId)))
596 break;
597 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->mplexId)))
598 break;
599 if (!ReadField(field) || string_to_uint8(field.c_str(), &(input->liveTVOrder)))
600 break;
601 list->push_back(input);
602 succeeded = true;
603 }
604 FlushMessage();
605 if (!succeeded)
606 break;
607 }
608 return list;
609}
610
611CardInputListPtr ProtoMonitor::GetFreeInputs79()
612{
613 CardInputListPtr list = CardInputListPtr(new CardInputList());
614 std::vector<int> cardList = GetFreeCardIdList75();
615 for (std::vector<int>::const_iterator cardIt = cardList.begin(); cardIt != cardList.end(); ++cardIt)
616 {
617 bool succeeded = false;
618 BUILTIN_BUFFER buf;
619 std::string field;
620
621 OS::WriteLock lock(*m_latch);
622 if (!IsOpen())
623 break;
624 std::string cmd("QUERY_RECORDER ");
625 int32_to_string((int32_t)(*cardIt), &buf);
626 cmd.append(buf.data);
627 cmd.append(PROTO_STR_SEPARATOR);
628 cmd.append("GET_FREE_INPUTS");
629
630 if (!SendCommand(cmd.c_str()))
631 break;
632
633 while (m_msgConsumed < m_msgLength)
634 {
635 CardInputPtr input(new CardInput());
636 if (!ReadField(input->inputName))
637 break;
638 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->sourceId)))
639 break;
640 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->inputId)))
641 break;
642 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->cardId)))
643 break;
644 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->mplexId)))
645 break;
646 if (!ReadField(field) || string_to_uint8(field.c_str(), &(input->liveTVOrder)))
647 break;
648 if (!ReadField(field)) // displayName
649 break;
650 if (!ReadField(field)) // recPriority
651 break;
652 if (!ReadField(field)) // schedOrder
653 break;
654 if (!ReadField(field)) // quickTune
655 break;
656 list->push_back(input);
657 succeeded = true;
658 }
659 FlushMessage();
660 if (!succeeded)
661 break;
662 }
663 return list;
664}
665
666CardInputListPtr ProtoMonitor::GetFreeInputs81()
667{
668 CardInputListPtr list = CardInputListPtr(new CardInputList());
669 std::vector<int> cardList = GetFreeCardIdList75();
670 for (std::vector<int>::const_iterator cardIt = cardList.begin(); cardIt != cardList.end(); ++cardIt)
671 {
672 bool succeeded = false;
673 BUILTIN_BUFFER buf;
674 std::string field;
675
676 OS::WriteLock lock(*m_latch);
677 if (!IsOpen())
678 break;
679 std::string cmd("QUERY_RECORDER ");
680 int32_to_string((int32_t)(*cardIt), &buf);
681 cmd.append(buf.data);
682 cmd.append(PROTO_STR_SEPARATOR);
683 cmd.append("GET_FREE_INPUTS");
684
685 if (!SendCommand(cmd.c_str()))
686 break;
687
688 while (m_msgConsumed < m_msgLength)
689 {
690 CardInputPtr input(new CardInput());
691 if (!ReadField(input->inputName))
692 break;
693 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->sourceId)))
694 break;
695 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->inputId)))
696 break;
697 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->cardId)))
698 break;
699 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->mplexId)))
700 break;
701 if (!ReadField(field) || string_to_uint8(field.c_str(), &(input->liveTVOrder)))
702 break;
703 if (!ReadField(field)) // displayName
704 break;
705 if (!ReadField(field)) // recPriority
706 break;
707 if (!ReadField(field)) // schedOrder
708 break;
709 if (!ReadField(field)) // quickTune
710 break;
711 if (!ReadField(field)) // chanid
712 break;
713 list->push_back(input);
714 succeeded = true;
715 }
716 FlushMessage();
717 if (!succeeded)
718 break;
719 }
720 return list;
721}
722
723CardInputListPtr ProtoMonitor::GetFreeInputs87(int rnum)
724{
725 CardInputListPtr list = CardInputListPtr(new CardInputList());
726 BUILTIN_BUFFER buf;
727 std::string field;
728
729 OS::WriteLock lock(*m_latch);
730 if (!IsOpen())
731 return list;
732 std::string cmd("GET_FREE_INPUT_INFO ");
733 int32_to_string((int32_t)rnum, &buf);
734 cmd.append(buf.data);
735
736 if (!SendCommand(cmd.c_str()))
737 return list;
738
739 while (m_msgConsumed < m_msgLength)
740 {
741 CardInputPtr input(new CardInput());
742 if (!ReadField(input->inputName))
743 break;
744 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->sourceId)))
745 break;
746 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->inputId)))
747 break;
748 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->cardId))) // obsolete: same as inputId
749 break;
750 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->mplexId)))
751 break;
752 if (!ReadField(field) || string_to_uint8(field.c_str(), &(input->liveTVOrder)))
753 break;
754 if (!ReadField(field)) // displayName
755 break;
756 if (!ReadField(field)) // recPriority
757 break;
758 if (!ReadField(field)) // schedOrder
759 break;
760 if (!ReadField(field)) // quickTune
761 break;
762 if (!ReadField(field)) // chanid
763 break;
764 list->push_back(input);
765 }
766 FlushMessage();
767 return list;
768}
769
770CardInputListPtr ProtoMonitor::GetFreeInputs89(int rnum)
771{
772 CardInputListPtr list = CardInputListPtr(new CardInputList());
773 BUILTIN_BUFFER buf;
774 std::string field;
775
776 OS::WriteLock lock(*m_latch);
777 if (!IsOpen())
778 return list;
779 std::string cmd("GET_FREE_INPUT_INFO ");
780 int32_to_string((int32_t)rnum, &buf);
781 cmd.append(buf.data);
782
783 if (!SendCommand(cmd.c_str()))
784 return list;
785
786 while (m_msgConsumed < m_msgLength)
787 {
788 CardInputPtr input(new CardInput());
789 if (!ReadField(input->inputName))
790 break;
791 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->sourceId)))
792 break;
793 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->inputId)))
794 break;
795 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->cardId))) // obsolete: same as inputId
796 break;
797 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->mplexId)))
798 break;
799 if (!ReadField(field) || string_to_uint8(field.c_str(), &(input->liveTVOrder)))
800 break;
801 if (!ReadField(field)) // displayName
802 break;
803 if (!ReadField(field)) // recPriority
804 break;
805 if (!ReadField(field)) // schedOrder
806 break;
807 if (!ReadField(field)) // quickTune
808 break;
809 if (!ReadField(field)) // chanid
810 break;
811 if (!ReadField(field)) // reclimit
812 break;
813 list->push_back(input);
814 }
815 FlushMessage();
816 return list;
817}
818
819CardInputListPtr ProtoMonitor::GetFreeInputs90(int rnum)
820{
821 CardInputListPtr list = CardInputListPtr(new CardInputList());
822 BUILTIN_BUFFER buf;
823 std::string field;
824
825 OS::WriteLock lock(*m_latch);
826 if (!IsOpen())
827 return list;
828 std::string cmd("GET_FREE_INPUT_INFO ");
829 int32_to_string((int32_t)rnum, &buf);
830 cmd.append(buf.data);
831
832 if (!SendCommand(cmd.c_str()))
833 return list;
834
835 while (m_msgConsumed < m_msgLength)
836 {
837 CardInputPtr input(new CardInput());
838 if (!ReadField(input->inputName))
839 break;
840 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->sourceId)))
841 break;
842 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->inputId)))
843 break;
844 input->cardId = input->inputId; // @FIXME: since protocol 90
845 if (!ReadField(field)) // reccount
846 break;
847 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->mplexId)))
848 break;
849 if (!ReadField(field) || string_to_uint8(field.c_str(), &(input->liveTVOrder)))
850 break;
851 if (!ReadField(field)) // displayName
852 break;
853 if (!ReadField(field)) // recPriority
854 break;
855 if (!ReadField(field)) // schedOrder
856 break;
857 if (!ReadField(field)) // quickTune
858 break;
859 if (!ReadField(field)) // chanid
860 break;
861 if (!ReadField(field)) // reclimit
862 break;
863 list->push_back(input);
864 }
865 FlushMessage();
866 return list;
867}
868
869CardInputListPtr ProtoMonitor::GetFreeInputs91(int rnum)
870{
871 CardInputListPtr list = CardInputListPtr(new CardInputList());
872 BUILTIN_BUFFER buf;
873 std::string field;
874
875 OS::WriteLock lock(*m_latch);
876 if (!IsOpen())
877 return list;
878 std::string cmd("GET_FREE_INPUT_INFO ");
879 int32_to_string((int32_t)rnum, &buf);
880 cmd.append(buf.data);
881
882 if (!SendCommand(cmd.c_str()))
883 return list;
884
885 while (m_msgConsumed < m_msgLength)
886 {
887 CardInputPtr input(new CardInput());
888 if (!ReadField(input->inputName))
889 break;
890 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->sourceId)))
891 break;
892 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->inputId)))
893 break;
894 input->cardId = input->inputId; // @FIXME: since protocol 90
895 if (!ReadField(field) || string_to_uint32(field.c_str(), &(input->mplexId)))
896 break;
897 if (!ReadField(field) || string_to_uint8(field.c_str(), &(input->liveTVOrder)))
898 break;
899 if (!ReadField(field)) // displayName
900 break;
901 if (!ReadField(field)) // recPriority
902 break;
903 if (!ReadField(field)) // schedOrder
904 break;
905 if (!ReadField(field)) // quickTune
906 break;
907 if (!ReadField(field)) // chanid
908 break;
909 list->push_back(input);
910 }
911 FlushMessage();
912 return list;
913}
Myth::ProtoBase::m_tainted
bool m_tainted
Connection has hung since last reset.
Definition mythprotobase.h:77
Myth::ProtoBase::ReadField
bool ReadField(std::string &field)
Definition mythprotobase.cpp:133
Myth::ProtoBase::m_hang
bool m_hang
Connection hang: while true allow retry.
Definition mythprotobase.h:76
Myth
This is the main namespace that encloses all public classes.
Definition mythcontrol.h:30