1 /*
2 *
3 * BlueZ - Bluetooth protocol stack for Linux
4 *
5 * Copyright (C) 2006-2010 Nokia Corporation
6 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 */
24
25 #ifdef HAVE_CONFIG_H
26 #include <config.h>
27 #endif
28
29 #include <stdio.h>
30 #include <errno.h>
31 #include <ctype.h>
32 #include <fcntl.h>
33 #include <unistd.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <getopt.h>
37 #include <stdint.h>
38 #include <sys/param.h>
39 #include <sys/ioctl.h>
40 #include <sys/socket.h>
41
42 #include <bluetooth/bluetooth.h>
43 #include <bluetooth/hci.h>
44 #include <bluetooth/hci_lib.h>
45 #include <bluetooth/l2cap.h>
46
47 #define AVDTP_PSM 25
48
49 /* Commands */
50 #define AVDTP_DISCOVER 0x01
51 #define AVDTP_GET_CAPABILITIES 0x02
52
53 #define AVDTP_PKT_TYPE_SINGLE 0x00
54
55 #define AVDTP_MSG_TYPE_COMMAND 0x00
56
57 /* SEP capability categories */
58 #define AVDTP_MEDIA_TRANSPORT 0x01
59 #define AVDTP_REPORTING 0x02
60 #define AVDTP_RECOVERY 0x03
61 #define AVDTP_CONTENT_PROTECTION 0x04
62 #define AVDTP_HEADER_COMPRESSION 0x05
63 #define AVDTP_MULTIPLEXING 0x06
64 #define AVDTP_MEDIA_CODEC 0x07
65
66 /* SEP types definitions */
67 #define AVDTP_SEP_TYPE_SOURCE 0x00
68 #define AVDTP_SEP_TYPE_SINK 0x01
69
70 /* Media types definitions */
71 #define AVDTP_MEDIA_TYPE_AUDIO 0x00
72 #define AVDTP_MEDIA_TYPE_VIDEO 0x01
73 #define AVDTP_MEDIA_TYPE_MULTIMEDIA 0x02
74
75 #define A2DP_CODEC_SBC 0x00
76 #define A2DP_CODEC_MPEG12 0x01
77 #define A2DP_CODEC_MPEG24 0x02
78 #define A2DP_CODEC_ATRAC 0x03
79
80 #define SBC_SAMPLING_FREQ_16000 (1 << 3)
81 #define SBC_SAMPLING_FREQ_32000 (1 << 2)
82 #define SBC_SAMPLING_FREQ_44100 (1 << 1)
83 #define SBC_SAMPLING_FREQ_48000 (1 << 0)
84
85 #define SBC_CHANNEL_MODE_MONO (1 << 3)
86 #define SBC_CHANNEL_MODE_DUAL_CHANNEL (1 << 2)
87 #define SBC_CHANNEL_MODE_STEREO (1 << 1)
88 #define SBC_CHANNEL_MODE_JOINT_STEREO (1 << 0)
89
90 #define SBC_BLOCK_LENGTH_4 (1 << 3)
91 #define SBC_BLOCK_LENGTH_8 (1 << 2)
92 #define SBC_BLOCK_LENGTH_12 (1 << 1)
93 #define SBC_BLOCK_LENGTH_16 (1 << 0)
94
95 #define SBC_SUBBANDS_4 (1 << 1)
96 #define SBC_SUBBANDS_8 (1 << 0)
97
98 #define SBC_ALLOCATION_SNR (1 << 1)
99 #define SBC_ALLOCATION_LOUDNESS (1 << 0)
100
101 #define MPEG_CHANNEL_MODE_MONO (1 << 3)
102 #define MPEG_CHANNEL_MODE_DUAL_CHANNEL (1 << 2)
103 #define MPEG_CHANNEL_MODE_STEREO (1 << 1)
104 #define MPEG_CHANNEL_MODE_JOINT_STEREO (1 << 0)
105
106 #define MPEG_LAYER_MP1 (1 << 2)
107 #define MPEG_LAYER_MP2 (1 << 1)
108 #define MPEG_LAYER_MP3 (1 << 0)
109
110 #define MPEG_SAMPLING_FREQ_16000 (1 << 5)
111 #define MPEG_SAMPLING_FREQ_22050 (1 << 4)
112 #define MPEG_SAMPLING_FREQ_24000 (1 << 3)
113 #define MPEG_SAMPLING_FREQ_32000 (1 << 2)
114 #define MPEG_SAMPLING_FREQ_44100 (1 << 1)
115 #define MPEG_SAMPLING_FREQ_48000 (1 << 0)
116
117 #define MPEG_BIT_RATE_VBR 0x8000
118 #define MPEG_BIT_RATE_320000 0x4000
119 #define MPEG_BIT_RATE_256000 0x2000
120 #define MPEG_BIT_RATE_224000 0x1000
121 #define MPEG_BIT_RATE_192000 0x0800
122 #define MPEG_BIT_RATE_160000 0x0400
123 #define MPEG_BIT_RATE_128000 0x0200
124 #define MPEG_BIT_RATE_112000 0x0100
125 #define MPEG_BIT_RATE_96000 0x0080
126 #define MPEG_BIT_RATE_80000 0x0040
127 #define MPEG_BIT_RATE_64000 0x0020
128 #define MPEG_BIT_RATE_56000 0x0010
129 #define MPEG_BIT_RATE_48000 0x0008
130 #define MPEG_BIT_RATE_40000 0x0004
131 #define MPEG_BIT_RATE_32000 0x0002
132 #define MPEG_BIT_RATE_FREE 0x0001
133
134 struct avdtp_service_capability {
135 uint8_t category;
136 uint8_t length;
137 uint8_t data[0];
138 } __attribute__ ((packed));
139
140 #if __BYTE_ORDER == __LITTLE_ENDIAN
141
142 struct avdtp_header {
143 uint8_t message_type:2;
144 uint8_t packet_type:2;
145 uint8_t transaction:4;
146 uint8_t signal_id:6;
147 uint8_t rfa0:2;
148 } __attribute__ ((packed));
149
150 struct seid_info {
151 uint8_t rfa0:1;
152 uint8_t inuse:1;
153 uint8_t seid:6;
154 uint8_t rfa2:3;
155 uint8_t type:1;
156 uint8_t media_type:4;
157 } __attribute__ ((packed));
158
159 struct seid_req {
160 struct avdtp_header header;
161 uint8_t rfa0:2;
162 uint8_t acp_seid:6;
163 } __attribute__ ((packed));
164
165 struct avdtp_media_codec_capability {
166 uint8_t rfa0:4;
167 uint8_t media_type:4;
168 uint8_t media_codec_type;
169 uint8_t data[0];
170 } __attribute__ ((packed));
171
172 struct sbc_codec_cap {
173 struct avdtp_media_codec_capability cap;
174 uint8_t channel_mode:4;
175 uint8_t frequency:4;
176 uint8_t allocation_method:2;
177 uint8_t subbands:2;
178 uint8_t block_length:4;
179 uint8_t min_bitpool;
180 uint8_t max_bitpool;
181 } __attribute__ ((packed));
182
183 struct mpeg_codec_cap {
184 struct avdtp_media_codec_capability cap;
185 uint8_t channel_mode:4;
186 uint8_t crc:1;
187 uint8_t layer:3;
188 uint8_t frequency:6;
189 uint8_t mpf:1;
190 uint8_t rfa:1;
191 uint16_t bitrate;
192 } __attribute__ ((packed));
193
194 #elif __BYTE_ORDER == __BIG_ENDIAN
195
196 struct avdtp_header {
197 uint8_t transaction:4;
198 uint8_t packet_type:2;
199 uint8_t message_type:2;
200 uint8_t rfa0:2;
201 uint8_t signal_id:6;
202 } __attribute__ ((packed));
203
204 struct seid_info {
205 uint8_t seid:6;
206 uint8_t inuse:1;
207 uint8_t rfa0:1;
208 uint8_t media_type:4;
209 uint8_t type:1;
210 uint8_t rfa2:3;
211 } __attribute__ ((packed));
212
213 struct seid_req {
214 struct avdtp_header header;
215 uint8_t acp_seid:6;
216 uint8_t rfa0:2;
217 } __attribute__ ((packed));
218
219 struct avdtp_media_codec_capability {
220 uint8_t media_type:4;
221 uint8_t rfa0:4;
222 uint8_t media_codec_type;
223 uint8_t data[0];
224 } __attribute__ ((packed));
225
226 struct sbc_codec_cap {
227 struct avdtp_media_codec_capability cap;
228 uint8_t frequency:4;
229 uint8_t channel_mode:4;
230 uint8_t block_length:4;
231 uint8_t subbands:2;
232 uint8_t allocation_method:2;
233 uint8_t min_bitpool;
234 uint8_t max_bitpool;
235 } __attribute__ ((packed));
236
237 struct mpeg_codec_cap {
238 struct avdtp_media_codec_capability cap;
239 uint8_t layer:3;
240 uint8_t crc:1;
241 uint8_t channel_mode:4;
242 uint8_t rfa:1;
243 uint8_t mpf:1;
244 uint8_t frequency:6;
245 uint16_t bitrate;
246 } __attribute__ ((packed));
247
248 #else
249 #error "Unknown byte order"
250 #endif
251
252 struct discover_resp {
253 struct avdtp_header header;
254 struct seid_info seps[0];
255 } __attribute__ ((packed));
256
257 struct getcap_resp {
258 struct avdtp_header header;
259 uint8_t caps[0];
260 } __attribute__ ((packed));
261
262
print_mpeg12(struct mpeg_codec_cap * mpeg)263 static void print_mpeg12(struct mpeg_codec_cap *mpeg)
264 {
265 printf("\tMedia Codec: MPEG12\n\t\tChannel Modes: ");
266
267 if (mpeg->channel_mode & MPEG_CHANNEL_MODE_MONO)
268 printf("Mono ");
269 if (mpeg->channel_mode & MPEG_CHANNEL_MODE_DUAL_CHANNEL)
270 printf("DualChannel ");
271 if (mpeg->channel_mode & MPEG_CHANNEL_MODE_STEREO)
272 printf("Stereo ");
273 if (mpeg->channel_mode & MPEG_CHANNEL_MODE_JOINT_STEREO)
274 printf("JointStereo");
275
276 printf("\n\t\tFrequencies: ");
277 if (mpeg->frequency & MPEG_SAMPLING_FREQ_16000)
278 printf("16Khz ");
279 if (mpeg->frequency & MPEG_SAMPLING_FREQ_22050)
280 printf("22.05Khz ");
281 if (mpeg->frequency & MPEG_SAMPLING_FREQ_24000)
282 printf("24Khz ");
283 if (mpeg->frequency & MPEG_SAMPLING_FREQ_32000)
284 printf("32Khz ");
285 if (mpeg->frequency & MPEG_SAMPLING_FREQ_44100)
286 printf("44.1Khz ");
287 if (mpeg->frequency & MPEG_SAMPLING_FREQ_48000)
288 printf("48Khz ");
289
290 printf("\n\t\tCRC: %s", mpeg->crc ? "Yes" : "No");
291
292 printf("\n\t\tLayer: ");
293 if (mpeg->layer & MPEG_LAYER_MP1)
294 printf("1 ");
295 if (mpeg->layer & MPEG_LAYER_MP2)
296 printf("2 ");
297 if (mpeg->layer & MPEG_LAYER_MP3)
298 printf("3 ");
299
300 printf("\n\t\tBit Rate: ");
301 if (mpeg->bitrate & MPEG_BIT_RATE_FREE)
302 printf("Free format");
303 else {
304 if (mpeg->bitrate & MPEG_BIT_RATE_32000)
305 printf("32kbps ");
306 if (mpeg->bitrate & MPEG_BIT_RATE_40000)
307 printf("40kbps ");
308 if (mpeg->bitrate & MPEG_BIT_RATE_48000)
309 printf("48kbps ");
310 if (mpeg->bitrate & MPEG_BIT_RATE_56000)
311 printf("56kbps ");
312 if (mpeg->bitrate & MPEG_BIT_RATE_64000)
313 printf("64kbps ");
314 if (mpeg->bitrate & MPEG_BIT_RATE_80000)
315 printf("80kbps ");
316 if (mpeg->bitrate & MPEG_BIT_RATE_96000)
317 printf("96kbps ");
318 if (mpeg->bitrate & MPEG_BIT_RATE_112000)
319 printf("112kbps ");
320 if (mpeg->bitrate & MPEG_BIT_RATE_128000)
321 printf("128kbps ");
322 if (mpeg->bitrate & MPEG_BIT_RATE_160000)
323 printf("160kbps ");
324 if (mpeg->bitrate & MPEG_BIT_RATE_192000)
325 printf("192kbps ");
326 if (mpeg->bitrate & MPEG_BIT_RATE_224000)
327 printf("224kbps ");
328 if (mpeg->bitrate & MPEG_BIT_RATE_256000)
329 printf("256kbps ");
330 if (mpeg->bitrate & MPEG_BIT_RATE_320000)
331 printf("320kbps ");
332 }
333
334 printf("\n\t\tVBR: %s", mpeg->bitrate & MPEG_BIT_RATE_VBR ? "Yes" :
335 "No");
336
337 printf("\n\t\tPayload Format: ");
338 if (mpeg->mpf)
339 printf("RFC-2250 RFC-3119\n");
340 else
341 printf("RFC-2250\n");
342 }
343
print_sbc(struct sbc_codec_cap * sbc)344 static void print_sbc(struct sbc_codec_cap *sbc)
345 {
346 printf("\tMedia Codec: SBC\n\t\tChannel Modes: ");
347
348 if (sbc->channel_mode & SBC_CHANNEL_MODE_MONO)
349 printf("Mono ");
350 if (sbc->channel_mode & SBC_CHANNEL_MODE_DUAL_CHANNEL)
351 printf("DualChannel ");
352 if (sbc->channel_mode & SBC_CHANNEL_MODE_STEREO)
353 printf("Stereo ");
354 if (sbc->channel_mode & SBC_CHANNEL_MODE_JOINT_STEREO)
355 printf("JointStereo");
356
357 printf("\n\t\tFrequencies: ");
358 if (sbc->frequency & SBC_SAMPLING_FREQ_16000)
359 printf("16Khz ");
360 if (sbc->frequency & SBC_SAMPLING_FREQ_32000)
361 printf("32Khz ");
362 if (sbc->frequency & SBC_SAMPLING_FREQ_44100)
363 printf("44.1Khz ");
364 if (sbc->frequency & SBC_SAMPLING_FREQ_48000)
365 printf("48Khz ");
366
367 printf("\n\t\tSubbands: ");
368 if (sbc->allocation_method & SBC_SUBBANDS_4)
369 printf("4 ");
370 if (sbc->allocation_method & SBC_SUBBANDS_8)
371 printf("8");
372
373 printf("\n\t\tBlocks: ");
374 if (sbc->block_length & SBC_BLOCK_LENGTH_4)
375 printf("4 ");
376 if (sbc->block_length & SBC_BLOCK_LENGTH_8)
377 printf("8 ");
378 if (sbc->block_length & SBC_BLOCK_LENGTH_12)
379 printf("12 ");
380 if (sbc->block_length & SBC_BLOCK_LENGTH_16)
381 printf("16 ");
382
383 printf("\n\t\tBitpool Range: %d-%d\n",
384 sbc->min_bitpool, sbc->max_bitpool);
385 }
386
print_media_codec(struct avdtp_media_codec_capability * cap)387 static void print_media_codec(struct avdtp_media_codec_capability *cap)
388 {
389 switch (cap->media_codec_type) {
390 case A2DP_CODEC_SBC:
391 print_sbc((void *) cap);
392 break;
393 case A2DP_CODEC_MPEG12:
394 print_mpeg12((void *) cap);
395 break;
396 default:
397 printf("\tMedia Codec: Unknown\n");
398 }
399 }
400
print_caps(void * data,int size)401 static void print_caps(void *data, int size)
402 {
403 int processed;
404
405 for (processed = 0; processed + 2 < size;) {
406 struct avdtp_service_capability *cap;
407
408 cap = data;
409
410 if (processed + 2 + cap->length > size) {
411 printf("Invalid capability data in getcap resp\n");
412 break;
413 }
414
415 switch (cap->category) {
416 case AVDTP_MEDIA_TRANSPORT:
417 case AVDTP_REPORTING:
418 case AVDTP_RECOVERY:
419 case AVDTP_CONTENT_PROTECTION:
420 case AVDTP_MULTIPLEXING:
421 /* FIXME: Add proper functions */
422 break;
423 case AVDTP_MEDIA_CODEC:
424 print_media_codec((void *) cap->data);
425 break;
426 }
427
428 processed += 2 + cap->length;
429 data += 2 + cap->length;
430 }
431 }
432
init_request(struct avdtp_header * header,int request_id)433 static void init_request(struct avdtp_header *header, int request_id)
434 {
435 static int transaction = 0;
436
437 header->packet_type = AVDTP_PKT_TYPE_SINGLE;
438 header->message_type = AVDTP_MSG_TYPE_COMMAND;
439 header->transaction = transaction;
440 header->signal_id = request_id;
441
442 /* clear rfa bits */
443 header->rfa0 = 0;
444
445 transaction = (transaction + 1) % 16;
446 }
447
avdtp_send(int sk,void * data,int len)448 static ssize_t avdtp_send(int sk, void *data, int len)
449 {
450 ssize_t ret;
451
452 ret = send(sk, data, len, 0);
453
454 if (ret < 0)
455 ret = -errno;
456 else if (ret != len)
457 ret = -EIO;
458
459 if (ret < 0) {
460 printf("Unable to send message: %s (%zd)\n",
461 strerror(-ret), -ret);
462 return ret;
463 }
464
465 return ret;
466 }
467
avdtp_receive(int sk,void * data,int len)468 static ssize_t avdtp_receive(int sk, void *data, int len)
469 {
470 ssize_t ret;
471
472 ret = recv(sk, data, len, 0);
473
474 if (ret < 0) {
475 printf("Unable to receive message: %s (%d)\n",
476 strerror(errno), errno);
477 return -errno;
478 }
479
480 return ret;
481 }
482
avdtp_get_caps(int sk,int seid)483 static ssize_t avdtp_get_caps(int sk, int seid)
484 {
485 struct seid_req req;
486 char buffer[1024];
487 struct getcap_resp *caps = (void *) buffer;
488 ssize_t ret;
489
490 memset(&req, 0, sizeof(req));
491 init_request(&req.header, AVDTP_GET_CAPABILITIES);
492 req.acp_seid = seid;
493
494 ret = avdtp_send(sk, &req, sizeof(req));
495 if (ret < 0)
496 return ret;
497
498 memset(&buffer, 0, sizeof(buffer));
499 ret = avdtp_receive(sk, caps, sizeof(buffer));
500 if (ret < 0)
501 return ret;
502
503 if ((size_t) ret < (sizeof(struct getcap_resp) + 4 +
504 sizeof(struct avdtp_media_codec_capability))) {
505 printf("Invalid capabilities\n");
506 return -1;
507 }
508
509 print_caps(caps, ret);
510
511 return 0;
512 }
513
avdtp_discover(int sk)514 static ssize_t avdtp_discover(int sk)
515 {
516 struct avdtp_header req;
517 char buffer[256];
518 struct discover_resp *discover = (void *) buffer;
519 int seps, i;
520 ssize_t ret;
521
522 memset(&req, 0, sizeof(req));
523 init_request(&req, AVDTP_DISCOVER);
524
525 ret = avdtp_send(sk, &req, sizeof(req));
526 if (ret < 0)
527 return ret;
528
529 memset(&buffer, 0, sizeof(buffer));
530 ret = avdtp_receive(sk, discover, sizeof(buffer));
531 if (ret < 0)
532 return ret;
533
534 seps = (ret - sizeof(struct avdtp_header)) / sizeof(struct seid_info);
535 for (i = 0; i < seps; i++) {
536 const char *type, *media;
537
538 switch (discover->seps[i].type) {
539 case AVDTP_SEP_TYPE_SOURCE:
540 type = "Source";
541 break;
542 case AVDTP_SEP_TYPE_SINK:
543 type = "Sink";
544 break;
545 default:
546 type = "Invalid";
547 }
548
549 switch (discover->seps[i].media_type) {
550 case AVDTP_MEDIA_TYPE_AUDIO:
551 media = "Audio";
552 break;
553 case AVDTP_MEDIA_TYPE_VIDEO:
554 media = "Video";
555 break;
556 case AVDTP_MEDIA_TYPE_MULTIMEDIA:
557 media = "Multimedia";
558 break;
559 default:
560 media = "Invalid";
561 }
562
563 printf("Stream End-Point #%d: %s %s %s\n",
564 discover->seps[i].seid, media, type,
565 discover->seps[i].inuse ? "*" : "");
566
567 avdtp_get_caps(sk, discover->seps[i].seid);
568 }
569
570 return 0;
571 }
572
l2cap_connect(bdaddr_t * src,bdaddr_t * dst)573 static int l2cap_connect(bdaddr_t *src, bdaddr_t *dst)
574 {
575 struct sockaddr_l2 l2a;
576 int sk;
577
578 memset(&l2a, 0, sizeof(l2a));
579 l2a.l2_family = AF_BLUETOOTH;
580 bacpy(&l2a.l2_bdaddr, src);
581
582 sk = socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
583 if (sk < 0) {
584 printf("Cannot create L2CAP socket. %s(%d)\n", strerror(errno),
585 errno);
586 return -errno;
587 }
588
589 if (bind(sk, (struct sockaddr *) &l2a, sizeof(l2a)) < 0) {
590 printf("Bind failed. %s (%d)\n", strerror(errno), errno);
591 return -errno;
592 }
593
594 memset(&l2a, 0, sizeof(l2a));
595 l2a.l2_family = AF_BLUETOOTH;
596 bacpy(&l2a.l2_bdaddr, dst);
597 l2a.l2_psm = htobs(AVDTP_PSM);
598
599 if (connect(sk, (struct sockaddr *) &l2a, sizeof(l2a)) < 0) {
600 printf("Connect failed. %s(%d)\n", strerror(errno), errno);
601 return -errno;
602 }
603
604 return sk;
605 }
606
usage(void)607 static void usage(void)
608 {
609 printf("avinfo - Audio/Video Info Tool ver %s\n", VERSION);
610 printf("Usage:\n"
611 "\tavinfo [options] <remote address>\n");
612 printf("Options:\n"
613 "\t-h\t\tDisplay help\n"
614 "\t-i\t\tSpecify source interface\n");
615 }
616
617 static struct option main_options[] = {
618 { "help", 0, 0, 'h' },
619 { "device", 1, 0, 'i' },
620 { 0, 0, 0, 0 }
621 };
622
main(int argc,char * argv[])623 int main(int argc, char *argv[])
624 {
625 bdaddr_t src, dst;
626 int opt, sk, dev_id;
627
628 if (argc < 2) {
629 usage();
630 exit(0);
631 }
632
633 bacpy(&src, BDADDR_ANY);
634 dev_id = hci_get_route(&src);
635 if ((dev_id < 0) || (hci_devba(dev_id, &src) < 0)) {
636 printf("Cannot find any local adapter\n");
637 exit(-1);
638 }
639
640 while ((opt = getopt_long(argc, argv, "+i:h", main_options, NULL)) != -1) {
641 switch (opt) {
642 case 'i':
643 if (!strncmp(optarg, "hci", 3))
644 hci_devba(atoi(optarg + 3), &src);
645 else
646 str2ba(optarg, &src);
647 break;
648
649 case 'h':
650 default:
651 usage();
652 exit(0);
653 }
654 }
655
656 printf("Connecting ... \n");
657
658 if (bachk(argv[optind]) < 0) {
659 printf("Invalid argument\n");
660 exit(1);
661 }
662
663 str2ba(argv[optind], &dst);
664 sk = l2cap_connect(&src, &dst);
665 if (sk < 0)
666 exit(1);
667
668 if (avdtp_discover(sk) < 0)
669 exit(1);
670
671 return 0;
672 }
673