b7f1cc69029a7689091787e831eaed66d2de4859
[melted] / src / valerie / valerie.c
1 /*
2 * valerie.c -- High Level Client API for miracle
3 * Copyright (C) 2002-2003 Ushodaya Enterprises Limited
4 * Author: Charles Yates <charles.yates@pandora.be>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 /* System header files */
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <stdarg.h>
26
27 /* Application header files */
28 #include "valerie.h"
29 #include "valerie_tokeniser.h"
30 #include "valerie_util.h"
31
32 /** Initialise the valerie structure.
33 */
34
35 valerie valerie_init( valerie_parser parser )
36 {
37 valerie this = malloc( sizeof( valerie_t ) );
38 if ( this != NULL )
39 {
40 memset( this, 0, sizeof( valerie_t ) );
41 this->parser = parser;
42 }
43 return this;
44 }
45
46 /** Set the response structure associated to the last command.
47 */
48
49 static void valerie_set_last_response( valerie this, valerie_response response )
50 {
51 if ( this != NULL )
52 {
53 if ( this->last_response != NULL )
54 valerie_response_close( this->last_response );
55 this->last_response = response;
56 }
57 }
58
59 /** Connect to the parser.
60 */
61
62 valerie_error_code valerie_connect( valerie this )
63 {
64 valerie_error_code error = valerie_server_unavailable;
65 valerie_response response = valerie_parser_connect( this->parser );
66 if ( response != NULL )
67 {
68 valerie_set_last_response( this, response );
69 if ( valerie_response_get_error_code( response ) == 100 )
70 error = valerie_ok;
71 }
72 return error;
73 }
74
75 /** Interpret a non-context sensitive error code.
76 */
77
78 static valerie_error_code valerie_get_error_code( valerie this, valerie_response response )
79 {
80 valerie_error_code error = valerie_server_unavailable;
81 switch( valerie_response_get_error_code( response ) )
82 {
83 case -1:
84 error = valerie_server_unavailable;
85 break;
86 case -2:
87 error = valerie_no_response;
88 break;
89 case 200:
90 case 201:
91 case 202:
92 error = valerie_ok;
93 break;
94 case 400:
95 error = valerie_invalid_command;
96 break;
97 case 401:
98 error = valerie_server_timeout;
99 break;
100 case 402:
101 error = valerie_missing_argument;
102 break;
103 case 403:
104 error = valerie_unit_unavailable;
105 break;
106 case 404:
107 error = valerie_invalid_file;
108 break;
109 default:
110 case 500:
111 error = valerie_unknown_error;
112 break;
113 }
114 return error;
115 }
116
117 /** Execute a command.
118 */
119
120 valerie_error_code valerie_execute( valerie this, size_t size, const char *format, ... )
121 {
122 valerie_error_code error = valerie_server_unavailable;
123 char *command = malloc( size );
124 if ( this != NULL && command != NULL )
125 {
126 va_list list;
127 va_start( list, format );
128 if ( vsnprintf( command, size, format, list ) != 0 )
129 {
130 valerie_response response = valerie_parser_execute( this->parser, command );
131 valerie_set_last_response( this, response );
132 error = valerie_get_error_code( this, response );
133 }
134 else
135 {
136 error = valerie_invalid_command;
137 }
138 va_end( list );
139 }
140 else
141 {
142 error = valerie_malloc_failed;
143 }
144 free( command );
145 return error;
146 }
147
148 /** Execute a command.
149 */
150
151 valerie_error_code valerie_receive( valerie this, char *doc, size_t size, const char *format, ... )
152 {
153 valerie_error_code error = valerie_server_unavailable;
154 char *command = malloc( size );
155 if ( this != NULL && command != NULL )
156 {
157 va_list list;
158 va_start( list, format );
159 if ( vsnprintf( command, size, format, list ) != 0 )
160 {
161 valerie_response response = valerie_parser_received( this->parser, command, doc );
162 valerie_set_last_response( this, response );
163 error = valerie_get_error_code( this, response );
164 }
165 else
166 {
167 error = valerie_invalid_command;
168 }
169 va_end( list );
170 }
171 else
172 {
173 error = valerie_malloc_failed;
174 }
175 free( command );
176 return error;
177 }
178
179 /** Execute a command.
180 */
181
182 valerie_error_code valerie_push( valerie this, mlt_service service, size_t size, const char *format, ... )
183 {
184 valerie_error_code error = valerie_server_unavailable;
185 char *command = malloc( size );
186 if ( this != NULL && command != NULL )
187 {
188 va_list list;
189 va_start( list, format );
190 if ( vsnprintf( command, size, format, list ) != 0 )
191 {
192 valerie_response response = valerie_parser_push( this->parser, command, service );
193 valerie_set_last_response( this, response );
194 error = valerie_get_error_code( this, response );
195 }
196 else
197 {
198 error = valerie_invalid_command;
199 }
200 va_end( list );
201 }
202 else
203 {
204 error = valerie_malloc_failed;
205 }
206 free( command );
207 return error;
208 }
209
210 /** Set a global property.
211 */
212
213 valerie_error_code valerie_set( valerie this, char *property, char *value )
214 {
215 return valerie_execute( this, 1024, "SET %s=%s", property, value );
216 }
217
218 /** Get a global property.
219 */
220
221 valerie_error_code valerie_get( valerie this, char *property, char *value, int length )
222 {
223 valerie_error_code error = valerie_execute( this, 1024, "GET %s", property );
224 if ( error == valerie_ok )
225 {
226 valerie_response response = valerie_get_last_response( this );
227 strncpy( value, valerie_response_get_line( response, 1 ), length );
228 }
229 return error;
230 }
231
232 /** Run a script.
233 */
234
235 valerie_error_code valerie_run( valerie this, char *file )
236 {
237 return valerie_execute( this, 10240, "RUN \"%s\"", file );
238 }
239
240 /** Add a unit.
241 */
242
243 valerie_error_code valerie_unit_add( valerie this, char *guid, int *unit )
244 {
245 valerie_error_code error = valerie_execute( this, 1024, "UADD %s", guid );
246 if ( error == valerie_ok )
247 {
248 int length = valerie_response_count( this->last_response );
249 char *line = valerie_response_get_line( this->last_response, length - 1 );
250 if ( line == NULL || sscanf( line, "U%d", unit ) != 1 )
251 error = valerie_unit_creation_failed;
252 }
253 else
254 {
255 if ( error == valerie_unknown_error )
256 error = valerie_unit_creation_failed;
257 }
258 return error;
259 }
260
261 /** Load a file on the specified unit.
262 */
263
264 valerie_error_code valerie_unit_load( valerie this, int unit, char *file )
265 {
266 return valerie_execute( this, 10240, "LOAD U%d \"%s\"", unit, file );
267 }
268
269 static void valerie_interpret_clip_offset( char *output, valerie_clip_offset offset, int clip )
270 {
271 switch( offset )
272 {
273 case valerie_absolute:
274 sprintf( output, "%d", clip );
275 break;
276 case valerie_relative:
277 if ( clip < 0 )
278 sprintf( output, "%d", clip );
279 else
280 sprintf( output, "+%d", clip );
281 break;
282 }
283 }
284
285 /** Load a file on the specified unit with the specified in/out points.
286 */
287
288 valerie_error_code valerie_unit_load_clipped( valerie this, int unit, char *file, int32_t in, int32_t out )
289 {
290 return valerie_execute( this, 10240, "LOAD U%d \"%s\" %d %d", unit, file, in, out );
291 }
292
293 /** Load a file on the specified unit at the end of the current pump.
294 */
295
296 valerie_error_code valerie_unit_load_back( valerie this, int unit, char *file )
297 {
298 return valerie_execute( this, 10240, "LOAD U%d \"!%s\"", unit, file );
299 }
300
301 /** Load a file on the specified unit at the end of the pump with the specified in/out points.
302 */
303
304 valerie_error_code valerie_unit_load_back_clipped( valerie this, int unit, char *file, int32_t in, int32_t out )
305 {
306 return valerie_execute( this, 10240, "LOAD U%d \"!%s\" %d %d", unit, file, in, out );
307 }
308
309 /** Append a file on the specified unit.
310 */
311
312 valerie_error_code valerie_unit_append( valerie this, int unit, char *file, int32_t in, int32_t out )
313 {
314 return valerie_execute( this, 10240, "APND U%d \"%s\" %d %d", unit, file, in, out );
315 }
316
317 /** Push a service on to a unit.
318 */
319
320 valerie_error_code valerie_unit_receive( valerie this, int unit, char *command, char *doc )
321 {
322 return valerie_receive( this, doc, 10240, "PUSH U%d %s", unit, command );
323 }
324
325 /** Push a service on to a unit.
326 */
327
328 valerie_error_code valerie_unit_push( valerie this, int unit, char *command, mlt_service service )
329 {
330 return valerie_push( this, service, 10240, "PUSH U%d %s", unit, command );
331 }
332
333 /** Clean the unit - this function removes all but the currently playing clip.
334 */
335
336 valerie_error_code valerie_unit_clean( valerie this, int unit )
337 {
338 return valerie_execute( this, 1024, "CLEAN U%d", unit );
339 }
340
341 /** Clear the unit - this function removes all clips.
342 */
343
344 valerie_error_code valerie_unit_clear( valerie this, int unit )
345 {
346 return valerie_execute( this, 1024, "CLEAR U%d", unit );
347 }
348
349 /** Wipe the unit - this function removes all clips before the current one.
350 */
351
352 valerie_error_code valerie_unit_wipe( valerie this, int unit )
353 {
354 return valerie_execute( this, 1024, "WIPE U%d", unit );
355 }
356
357 /** Move clips on the units playlist.
358 */
359
360 valerie_error_code valerie_unit_clip_move( valerie this, int unit, valerie_clip_offset src_offset, int src, valerie_clip_offset dest_offset, int dest )
361 {
362 char temp1[ 100 ];
363 char temp2[ 100 ];
364 valerie_interpret_clip_offset( temp1, src_offset, src );
365 valerie_interpret_clip_offset( temp2, dest_offset, dest );
366 return valerie_execute( this, 1024, "MOVE U%d %s %s", unit, temp1, temp2 );
367 }
368
369 /** Remove clip at the specified position.
370 */
371
372 valerie_error_code valerie_unit_clip_remove( valerie this, int unit, valerie_clip_offset offset, int clip )
373 {
374 char temp[ 100 ];
375 valerie_interpret_clip_offset( temp, offset, clip );
376 return valerie_execute( this, 1024, "REMOVE U%d %s", unit, temp );
377 }
378
379 /** Remove the currently playing clip.
380 */
381
382 valerie_error_code valerie_unit_remove_current_clip( valerie this, int unit )
383 {
384 return valerie_execute( this, 1024, "REMOVE U%d", unit );
385 }
386
387 /** Insert clip at the specified position.
388 */
389
390 valerie_error_code valerie_unit_clip_insert( valerie this, int unit, valerie_clip_offset offset, int clip, char *file, int32_t in, int32_t out )
391 {
392 char temp[ 100 ];
393 valerie_interpret_clip_offset( temp, offset, clip );
394 return valerie_execute( this, 1024, "INSERT U%d \"%s\" %s %d %d", unit, file, temp, in, out );
395 }
396
397 /** Play the unit at normal speed.
398 */
399
400 valerie_error_code valerie_unit_play( valerie this, int unit )
401 {
402 return valerie_execute( this, 1024, "PLAY U%d 1000", unit );
403 }
404
405 /** Play the unit at specified speed.
406 */
407
408 valerie_error_code valerie_unit_play_at_speed( valerie this, int unit, int speed )
409 {
410 return valerie_execute( this, 10240, "PLAY U%d %d", unit, speed );
411 }
412
413 /** Stop playback on the specified unit.
414 */
415
416 valerie_error_code valerie_unit_stop( valerie this, int unit )
417 {
418 return valerie_execute( this, 1024, "STOP U%d", unit );
419 }
420
421 /** Pause playback on the specified unit.
422 */
423
424 valerie_error_code valerie_unit_pause( valerie this, int unit )
425 {
426 return valerie_execute( this, 1024, "PAUSE U%d", unit );
427 }
428
429 /** Rewind the specified unit.
430 */
431
432 valerie_error_code valerie_unit_rewind( valerie this, int unit )
433 {
434 return valerie_execute( this, 1024, "REW U%d", unit );
435 }
436
437 /** Fast forward the specified unit.
438 */
439
440 valerie_error_code valerie_unit_fast_forward( valerie this, int unit )
441 {
442 return valerie_execute( this, 1024, "FF U%d", unit );
443 }
444
445 /** Step by the number of frames on the specified unit.
446 */
447
448 valerie_error_code valerie_unit_step( valerie this, int unit, int32_t step )
449 {
450 return valerie_execute( this, 1024, "STEP U%d %d", unit, step );
451 }
452
453 /** Goto the specified frame on the specified unit.
454 */
455
456 valerie_error_code valerie_unit_goto( valerie this, int unit, int32_t position )
457 {
458 return valerie_execute( this, 1024, "GOTO U%d %d", unit, position );
459 }
460
461 /** Goto the specified frame in the clip on the specified unit.
462 */
463
464 valerie_error_code valerie_unit_clip_goto( valerie this, int unit, valerie_clip_offset offset, int clip, int32_t position )
465 {
466 char temp[ 100 ];
467 valerie_interpret_clip_offset( temp, offset, clip );
468 return valerie_execute( this, 1024, "GOTO U%d %d %s", unit, position, temp );
469 }
470
471 /** Set the in point of the loaded file on the specified unit.
472 */
473
474 valerie_error_code valerie_unit_set_in( valerie this, int unit, int32_t in )
475 {
476 return valerie_execute( this, 1024, "SIN U%d %d", unit, in );
477 }
478
479 /** Set the in point of the clip on the specified unit.
480 */
481
482 valerie_error_code valerie_unit_clip_set_in( valerie this, int unit, valerie_clip_offset offset, int clip, int32_t in )
483 {
484 char temp[ 100 ];
485 valerie_interpret_clip_offset( temp, offset, clip );
486 return valerie_execute( this, 1024, "SIN U%d %d %s", unit, in, temp );
487 }
488
489 /** Set the out point of the loaded file on the specified unit.
490 */
491
492 valerie_error_code valerie_unit_set_out( valerie this, int unit, int32_t out )
493 {
494 return valerie_execute( this, 1024, "SOUT U%d %d", unit, out );
495 }
496
497 /** Set the out point of the clip on the specified unit.
498 */
499
500 valerie_error_code valerie_unit_clip_set_out( valerie this, int unit, valerie_clip_offset offset, int clip, int32_t in )
501 {
502 char temp[ 100 ];
503 valerie_interpret_clip_offset( temp, offset, clip );
504 return valerie_execute( this, 1024, "SOUT U%d %d %s", unit, in, temp );
505 }
506
507 /** Clear the in point of the loaded file on the specified unit.
508 */
509
510 valerie_error_code valerie_unit_clear_in( valerie this, int unit )
511 {
512 return valerie_execute( this, 1024, "SIN U%d -1", unit );
513 }
514
515 /** Clear the out point of the loaded file on the specified unit.
516 */
517
518 valerie_error_code valerie_unit_clear_out( valerie this, int unit )
519 {
520 return valerie_execute( this, 1024, "SOUT U%d -1", unit );
521 }
522
523 /** Clear the in and out points on the loaded file on the specified unit.
524 */
525
526 valerie_error_code valerie_unit_clear_in_out( valerie this, int unit )
527 {
528 valerie_error_code error = valerie_unit_clear_out( this, unit );
529 if ( error == valerie_ok )
530 error = valerie_unit_clear_in( this, unit );
531 return error;
532 }
533
534 /** Set a unit configuration property.
535 */
536
537 valerie_error_code valerie_unit_set( valerie this, int unit, const char *name, const char *value )
538 {
539 return valerie_execute( this, 1024, "USET U%d %s=%s", unit, name, value );
540 }
541
542 /** Get a unit configuration property.
543 */
544
545 valerie_error_code valerie_unit_get( valerie this, int unit, char *name )
546 {
547 return valerie_execute( this, 1024, "UGET U%d %s", unit, name );
548 }
549
550 /** Get a units status.
551 */
552
553 valerie_error_code valerie_unit_status( valerie this, int unit, valerie_status status )
554 {
555 valerie_error_code error = valerie_execute( this, 1024, "USTA U%d", unit );
556 int error_code = valerie_response_get_error_code( this->last_response );
557
558 memset( status, 0, sizeof( valerie_status_t ) );
559 status->unit = unit;
560 if ( error_code == 202 && valerie_response_count( this->last_response ) == 2 )
561 valerie_status_parse( status, valerie_response_get_line( this->last_response, 1 ) );
562 else if ( error_code == 403 )
563 status->status = unit_undefined;
564
565 return error;
566 }
567
568 /** Transfer the current settings of unit src to unit dest.
569 */
570
571 valerie_error_code valerie_unit_transfer( valerie this, int src, int dest )
572 {
573 return valerie_execute( this, 1024, "XFER U%d U%d", src, dest );
574 }
575
576 /** Obtain the parsers notifier.
577 */
578
579 valerie_notifier valerie_get_notifier( valerie this )
580 {
581 if ( this != NULL )
582 return valerie_parser_get_notifier( this->parser );
583 else
584 return NULL;
585 }
586
587 /** List the contents of the specified directory.
588 */
589
590 valerie_dir valerie_dir_init( valerie this, const char *directory )
591 {
592 valerie_dir dir = malloc( sizeof( valerie_dir_t ) );
593 if ( dir != NULL )
594 {
595 memset( dir, 0, sizeof( valerie_dir_t ) );
596 dir->directory = strdup( directory );
597 dir->response = valerie_parser_executef( this->parser, "CLS \"%s\"", directory );
598 }
599 return dir;
600 }
601
602 /** Return the error code associated to the dir.
603 */
604
605 valerie_error_code valerie_dir_get_error_code( valerie_dir dir )
606 {
607 if ( dir != NULL )
608 return valerie_get_error_code( NULL, dir->response );
609 else
610 return valerie_malloc_failed;
611 }
612
613 /** Get a particular file entry in the directory.
614 */
615
616 valerie_error_code valerie_dir_get( valerie_dir dir, int index, valerie_dir_entry entry )
617 {
618 valerie_error_code error = valerie_ok;
619 memset( entry, 0, sizeof( valerie_dir_entry_t ) );
620 if ( index < valerie_dir_count( dir ) )
621 {
622 char *line = valerie_response_get_line( dir->response, index + 1 );
623 valerie_tokeniser tokeniser = valerie_tokeniser_init( );
624 valerie_tokeniser_parse_new( tokeniser, line, " " );
625
626 if ( valerie_tokeniser_count( tokeniser ) > 0 )
627 {
628 valerie_util_strip( valerie_tokeniser_get_string( tokeniser, 0 ), '\"' );
629 strcpy( entry->full, dir->directory );
630 if ( entry->full[ strlen( entry->full ) - 1 ] != '/' )
631 strcat( entry->full, "/" );
632 strcpy( entry->name, valerie_tokeniser_get_string( tokeniser, 0 ) );
633 strcat( entry->full, entry->name );
634
635 switch ( valerie_tokeniser_count( tokeniser ) )
636 {
637 case 1:
638 entry->dir = 1;
639 break;
640 case 2:
641 entry->size = strtoull( valerie_tokeniser_get_string( tokeniser, 1 ), NULL, 10 );
642 break;
643 default:
644 error = valerie_invalid_file;
645 break;
646 }
647 }
648 valerie_tokeniser_close( tokeniser );
649 }
650 return error;
651 }
652
653 /** Get the number of entries in the directory
654 */
655
656 int valerie_dir_count( valerie_dir dir )
657 {
658 if ( dir != NULL && valerie_response_count( dir->response ) >= 2 )
659 return valerie_response_count( dir->response ) - 2;
660 else
661 return -1;
662 }
663
664 /** Close the directory structure.
665 */
666
667 void valerie_dir_close( valerie_dir dir )
668 {
669 if ( dir != NULL )
670 {
671 free( dir->directory );
672 valerie_response_close( dir->response );
673 free( dir );
674 }
675 }
676
677 /** List the playlist of the specified unit.
678 */
679
680 valerie_list valerie_list_init( valerie this, int unit )
681 {
682 valerie_list list = calloc( 1, sizeof( valerie_list_t ) );
683 if ( list != NULL )
684 {
685 list->response = valerie_parser_executef( this->parser, "LIST U%d", unit );
686 if ( valerie_response_count( list->response ) >= 2 )
687 list->generation = atoi( valerie_response_get_line( list->response, 1 ) );
688 }
689 return list;
690 }
691
692 /** Return the error code associated to the list.
693 */
694
695 valerie_error_code valerie_list_get_error_code( valerie_list list )
696 {
697 if ( list != NULL )
698 return valerie_get_error_code( NULL, list->response );
699 else
700 return valerie_malloc_failed;
701 }
702
703 /** Get a particular file entry in the list.
704 */
705
706 valerie_error_code valerie_list_get( valerie_list list, int index, valerie_list_entry entry )
707 {
708 valerie_error_code error = valerie_ok;
709 memset( entry, 0, sizeof( valerie_list_entry_t ) );
710 if ( index < valerie_list_count( list ) )
711 {
712 char *line = valerie_response_get_line( list->response, index + 2 );
713 valerie_tokeniser tokeniser = valerie_tokeniser_init( );
714 valerie_tokeniser_parse_new( tokeniser, line, " " );
715
716 if ( valerie_tokeniser_count( tokeniser ) > 0 )
717 {
718 entry->clip = atoi( valerie_tokeniser_get_string( tokeniser, 0 ) );
719 valerie_util_strip( valerie_tokeniser_get_string( tokeniser, 1 ), '\"' );
720 strcpy( entry->full, valerie_tokeniser_get_string( tokeniser, 1 ) );
721 entry->in = atol( valerie_tokeniser_get_string( tokeniser, 2 ) );
722 entry->out = atol( valerie_tokeniser_get_string( tokeniser, 3 ) );
723 entry->max = atol( valerie_tokeniser_get_string( tokeniser, 4 ) );
724 entry->size = atol( valerie_tokeniser_get_string( tokeniser, 5 ) );
725 entry->fps = atof( valerie_tokeniser_get_string( tokeniser, 6 ) );
726 }
727 valerie_tokeniser_close( tokeniser );
728 }
729 return error;
730 }
731
732 /** Get the number of entries in the list
733 */
734
735 int valerie_list_count( valerie_list list )
736 {
737 if ( list != NULL && valerie_response_count( list->response ) >= 3 )
738 return valerie_response_count( list->response ) - 3;
739 else
740 return -1;
741 }
742
743 /** Close the list structure.
744 */
745
746 void valerie_list_close( valerie_list list )
747 {
748 if ( list != NULL )
749 {
750 valerie_response_close( list->response );
751 free( list );
752 }
753 }
754
755 /** List the currently connected nodes.
756 */
757
758 valerie_nodes valerie_nodes_init( valerie this )
759 {
760 valerie_nodes nodes = malloc( sizeof( valerie_nodes_t ) );
761 if ( nodes != NULL )
762 {
763 memset( nodes, 0, sizeof( valerie_nodes_t ) );
764 nodes->response = valerie_parser_executef( this->parser, "NLS" );
765 }
766 return nodes;
767 }
768
769 /** Return the error code associated to the nodes list.
770 */
771
772 valerie_error_code valerie_nodes_get_error_code( valerie_nodes nodes )
773 {
774 if ( nodes != NULL )
775 return valerie_get_error_code( NULL, nodes->response );
776 else
777 return valerie_malloc_failed;
778 }
779
780 /** Get a particular node entry.
781 */
782
783 valerie_error_code valerie_nodes_get( valerie_nodes nodes, int index, valerie_node_entry entry )
784 {
785 valerie_error_code error = valerie_ok;
786 memset( entry, 0, sizeof( valerie_node_entry_t ) );
787 if ( index < valerie_nodes_count( nodes ) )
788 {
789 char *line = valerie_response_get_line( nodes->response, index + 1 );
790 valerie_tokeniser tokeniser = valerie_tokeniser_init( );
791 valerie_tokeniser_parse_new( tokeniser, line, " " );
792
793 if ( valerie_tokeniser_count( tokeniser ) == 3 )
794 {
795 entry->node = atoi( valerie_tokeniser_get_string( tokeniser, 0 ) );
796 strncpy( entry->guid, valerie_tokeniser_get_string( tokeniser, 1 ), sizeof( entry->guid ) );
797 valerie_util_strip( valerie_tokeniser_get_string( tokeniser, 2 ), '\"' );
798 strncpy( entry->name, valerie_tokeniser_get_string( tokeniser, 2 ), sizeof( entry->name ) );
799 }
800
801 valerie_tokeniser_close( tokeniser );
802 }
803 return error;
804 }
805
806 /** Get the number of nodes
807 */
808
809 int valerie_nodes_count( valerie_nodes nodes )
810 {
811 if ( nodes != NULL && valerie_response_count( nodes->response ) >= 2 )
812 return valerie_response_count( nodes->response ) - 2;
813 else
814 return -1;
815 }
816
817 /** Close the nodes structure.
818 */
819
820 void valerie_nodes_close( valerie_nodes nodes )
821 {
822 if ( nodes != NULL )
823 {
824 valerie_response_close( nodes->response );
825 free( nodes );
826 }
827 }
828
829 /** List the currently defined units.
830 */
831
832 valerie_units valerie_units_init( valerie this )
833 {
834 valerie_units units = malloc( sizeof( valerie_units_t ) );
835 if ( units != NULL )
836 {
837 memset( units, 0, sizeof( valerie_units_t ) );
838 units->response = valerie_parser_executef( this->parser, "ULS" );
839 }
840 return units;
841 }
842
843 /** Return the error code associated to the nodes list.
844 */
845
846 valerie_error_code valerie_units_get_error_code( valerie_units units )
847 {
848 if ( units != NULL )
849 return valerie_get_error_code( NULL, units->response );
850 else
851 return valerie_malloc_failed;
852 }
853
854 /** Get a particular unit entry.
855 */
856
857 valerie_error_code valerie_units_get( valerie_units units, int index, valerie_unit_entry entry )
858 {
859 valerie_error_code error = valerie_ok;
860 memset( entry, 0, sizeof( valerie_unit_entry_t ) );
861 if ( index < valerie_units_count( units ) )
862 {
863 char *line = valerie_response_get_line( units->response, index + 1 );
864 valerie_tokeniser tokeniser = valerie_tokeniser_init( );
865 valerie_tokeniser_parse_new( tokeniser, line, " " );
866
867 if ( valerie_tokeniser_count( tokeniser ) == 4 )
868 {
869 entry->unit = atoi( valerie_tokeniser_get_string( tokeniser, 0 ) + 1 );
870 entry->node = atoi( valerie_tokeniser_get_string( tokeniser, 1 ) );
871 strncpy( entry->guid, valerie_tokeniser_get_string( tokeniser, 2 ), sizeof( entry->guid ) );
872 entry->online = atoi( valerie_tokeniser_get_string( tokeniser, 3 ) );
873 }
874
875 valerie_tokeniser_close( tokeniser );
876 }
877 return error;
878 }
879
880 /** Get the number of units
881 */
882
883 int valerie_units_count( valerie_units units )
884 {
885 if ( units != NULL && valerie_response_count( units->response ) >= 2 )
886 return valerie_response_count( units->response ) - 2;
887 else
888 return -1;
889 }
890
891 /** Close the units structure.
892 */
893
894 void valerie_units_close( valerie_units units )
895 {
896 if ( units != NULL )
897 {
898 valerie_response_close( units->response );
899 free( units );
900 }
901 }
902
903 /** Get the response of the last command executed.
904 */
905
906 valerie_response valerie_get_last_response( valerie this )
907 {
908 return this->last_response;
909 }
910
911 /** Obtain a printable message associated to the error code provided.
912 */
913
914 const char *valerie_error_description( valerie_error_code error )
915 {
916 const char *msg = "Unrecognised error";
917 switch( error )
918 {
919 case valerie_ok:
920 msg = "OK";
921 break;
922 case valerie_malloc_failed:
923 msg = "Memory allocation error";
924 break;
925 case valerie_unknown_error:
926 msg = "Unknown error";
927 break;
928 case valerie_no_response:
929 msg = "No response obtained";
930 break;
931 case valerie_invalid_command:
932 msg = "Invalid command";
933 break;
934 case valerie_server_timeout:
935 msg = "Communications with server timed out";
936 break;
937 case valerie_missing_argument:
938 msg = "Missing argument";
939 break;
940 case valerie_server_unavailable:
941 msg = "Unable to communicate with server";
942 break;
943 case valerie_unit_creation_failed:
944 msg = "Unit creation failed";
945 break;
946 case valerie_unit_unavailable:
947 msg = "Unit unavailable";
948 break;
949 case valerie_invalid_file:
950 msg = "Invalid file";
951 break;
952 case valerie_invalid_position:
953 msg = "Invalid position";
954 break;
955 }
956 return msg;
957 }
958
959 /** Close the valerie structure.
960 */
961
962 void valerie_close( valerie this )
963 {
964 if ( this != NULL )
965 {
966 valerie_set_last_response( this, NULL );
967 free( this );
968 }
969 }