Root/net/tipc/bearer.c

1/*
2 * net/tipc/bearer.c: TIPC bearer code
3 *
4 * Copyright (c) 1996-2006, Ericsson AB
5 * Copyright (c) 2004-2006, Wind River Systems
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
19 *
20 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
37#include "core.h"
38#include "config.h"
39#include "dbg.h"
40#include "bearer.h"
41#include "link.h"
42#include "port.h"
43#include "discover.h"
44#include "bcast.h"
45
46#define MAX_ADDR_STR 32
47
48static struct media media_list[MAX_MEDIA];
49static u32 media_count = 0;
50
51struct bearer tipc_bearers[MAX_BEARERS];
52
53/**
54 * media_name_valid - validate media name
55 *
56 * Returns 1 if media name is valid, otherwise 0.
57 */
58
59static int media_name_valid(const char *name)
60{
61    u32 len;
62
63    len = strlen(name);
64    if ((len + 1) > TIPC_MAX_MEDIA_NAME)
65        return 0;
66    return (strspn(name, tipc_alphabet) == len);
67}
68
69/**
70 * media_find - locates specified media object by name
71 */
72
73static struct media *media_find(const char *name)
74{
75    struct media *m_ptr;
76    u32 i;
77
78    for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
79        if (!strcmp(m_ptr->name, name))
80            return m_ptr;
81    }
82    return NULL;
83}
84
85/**
86 * tipc_register_media - register a media type
87 *
88 * Bearers for this media type must be activated separately at a later stage.
89 */
90
91int tipc_register_media(u32 media_type,
92             char *name,
93             int (*enable)(struct tipc_bearer *),
94             void (*disable)(struct tipc_bearer *),
95             int (*send_msg)(struct sk_buff *,
96                     struct tipc_bearer *,
97                     struct tipc_media_addr *),
98             char *(*addr2str)(struct tipc_media_addr *a,
99                       char *str_buf, int str_size),
100             struct tipc_media_addr *bcast_addr,
101             const u32 bearer_priority,
102             const u32 link_tolerance, /* [ms] */
103             const u32 send_window_limit)
104{
105    struct media *m_ptr;
106    u32 media_id;
107    u32 i;
108    int res = -EINVAL;
109
110    write_lock_bh(&tipc_net_lock);
111
112    if (tipc_mode != TIPC_NET_MODE) {
113        warn("Media <%s> rejected, not in networked mode yet\n", name);
114        goto exit;
115    }
116    if (!media_name_valid(name)) {
117        warn("Media <%s> rejected, illegal name\n", name);
118        goto exit;
119    }
120    if (!bcast_addr) {
121        warn("Media <%s> rejected, no broadcast address\n", name);
122        goto exit;
123    }
124    if ((bearer_priority < TIPC_MIN_LINK_PRI) ||
125        (bearer_priority > TIPC_MAX_LINK_PRI)) {
126        warn("Media <%s> rejected, illegal priority (%u)\n", name,
127             bearer_priority);
128        goto exit;
129    }
130    if ((link_tolerance < TIPC_MIN_LINK_TOL) ||
131        (link_tolerance > TIPC_MAX_LINK_TOL)) {
132        warn("Media <%s> rejected, illegal tolerance (%u)\n", name,
133             link_tolerance);
134        goto exit;
135    }
136
137    media_id = media_count++;
138    if (media_id >= MAX_MEDIA) {
139        warn("Media <%s> rejected, media limit reached (%u)\n", name,
140             MAX_MEDIA);
141        media_count--;
142        goto exit;
143    }
144    for (i = 0; i < media_id; i++) {
145        if (media_list[i].type_id == media_type) {
146            warn("Media <%s> rejected, duplicate type (%u)\n", name,
147                 media_type);
148            media_count--;
149            goto exit;
150        }
151        if (!strcmp(name, media_list[i].name)) {
152            warn("Media <%s> rejected, duplicate name\n", name);
153            media_count--;
154            goto exit;
155        }
156    }
157
158    m_ptr = &media_list[media_id];
159    m_ptr->type_id = media_type;
160    m_ptr->send_msg = send_msg;
161    m_ptr->enable_bearer = enable;
162    m_ptr->disable_bearer = disable;
163    m_ptr->addr2str = addr2str;
164    memcpy(&m_ptr->bcast_addr, bcast_addr, sizeof(*bcast_addr));
165    m_ptr->bcast = 1;
166    strcpy(m_ptr->name, name);
167    m_ptr->priority = bearer_priority;
168    m_ptr->tolerance = link_tolerance;
169    m_ptr->window = send_window_limit;
170    dbg("Media <%s> registered\n", name);
171    res = 0;
172exit:
173    write_unlock_bh(&tipc_net_lock);
174    return res;
175}
176
177/**
178 * tipc_media_addr_printf - record media address in print buffer
179 */
180
181void tipc_media_addr_printf(struct print_buf *pb, struct tipc_media_addr *a)
182{
183    struct media *m_ptr;
184    u32 media_type;
185    u32 i;
186
187    media_type = ntohl(a->type);
188    for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
189        if (m_ptr->type_id == media_type)
190            break;
191    }
192
193    if ((i < media_count) && (m_ptr->addr2str != NULL)) {
194        char addr_str[MAX_ADDR_STR];
195
196        tipc_printf(pb, "%s(%s)", m_ptr->name,
197                m_ptr->addr2str(a, addr_str, sizeof(addr_str)));
198    } else {
199        unchar *addr = (unchar *)&a->dev_addr;
200
201        tipc_printf(pb, "UNKNOWN(%u)", media_type);
202        for (i = 0; i < (sizeof(*a) - sizeof(a->type)); i++) {
203            tipc_printf(pb, "-%02x", addr[i]);
204        }
205    }
206}
207
208/**
209 * tipc_media_get_names - record names of registered media in buffer
210 */
211
212struct sk_buff *tipc_media_get_names(void)
213{
214    struct sk_buff *buf;
215    struct media *m_ptr;
216    int i;
217
218    buf = tipc_cfg_reply_alloc(MAX_MEDIA * TLV_SPACE(TIPC_MAX_MEDIA_NAME));
219    if (!buf)
220        return NULL;
221
222    read_lock_bh(&tipc_net_lock);
223    for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
224        tipc_cfg_append_tlv(buf, TIPC_TLV_MEDIA_NAME, m_ptr->name,
225                    strlen(m_ptr->name) + 1);
226    }
227    read_unlock_bh(&tipc_net_lock);
228    return buf;
229}
230
231/**
232 * bearer_name_validate - validate & (optionally) deconstruct bearer name
233 * @name - ptr to bearer name string
234 * @name_parts - ptr to area for bearer name components (or NULL if not needed)
235 *
236 * Returns 1 if bearer name is valid, otherwise 0.
237 */
238
239static int bearer_name_validate(const char *name,
240                struct bearer_name *name_parts)
241{
242    char name_copy[TIPC_MAX_BEARER_NAME];
243    char *media_name;
244    char *if_name;
245    u32 media_len;
246    u32 if_len;
247
248    /* copy bearer name & ensure length is OK */
249
250    name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
251    /* need above in case non-Posix strncpy() doesn't pad with nulls */
252    strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
253    if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
254        return 0;
255
256    /* ensure all component parts of bearer name are present */
257
258    media_name = name_copy;
259    if ((if_name = strchr(media_name, ':')) == NULL)
260        return 0;
261    *(if_name++) = 0;
262    media_len = if_name - media_name;
263    if_len = strlen(if_name) + 1;
264
265    /* validate component parts of bearer name */
266
267    if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
268        (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME) ||
269        (strspn(media_name, tipc_alphabet) != (media_len - 1)) ||
270        (strspn(if_name, tipc_alphabet) != (if_len - 1)))
271        return 0;
272
273    /* return bearer name components, if necessary */
274
275    if (name_parts) {
276        strcpy(name_parts->media_name, media_name);
277        strcpy(name_parts->if_name, if_name);
278    }
279    return 1;
280}
281
282/**
283 * bearer_find - locates bearer object with matching bearer name
284 */
285
286static struct bearer *bearer_find(const char *name)
287{
288    struct bearer *b_ptr;
289    u32 i;
290
291    if (tipc_mode != TIPC_NET_MODE)
292        return NULL;
293
294    for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
295        if (b_ptr->active && (!strcmp(b_ptr->publ.name, name)))
296            return b_ptr;
297    }
298    return NULL;
299}
300
301/**
302 * tipc_bearer_find_interface - locates bearer object with matching interface name
303 */
304
305struct bearer *tipc_bearer_find_interface(const char *if_name)
306{
307    struct bearer *b_ptr;
308    char *b_if_name;
309    u32 i;
310
311    for (i = 0, b_ptr = tipc_bearers; i < MAX_BEARERS; i++, b_ptr++) {
312        if (!b_ptr->active)
313            continue;
314        b_if_name = strchr(b_ptr->publ.name, ':') + 1;
315        if (!strcmp(b_if_name, if_name))
316            return b_ptr;
317    }
318    return NULL;
319}
320
321/**
322 * tipc_bearer_get_names - record names of bearers in buffer
323 */
324
325struct sk_buff *tipc_bearer_get_names(void)
326{
327    struct sk_buff *buf;
328    struct media *m_ptr;
329    struct bearer *b_ptr;
330    int i, j;
331
332    buf = tipc_cfg_reply_alloc(MAX_BEARERS * TLV_SPACE(TIPC_MAX_BEARER_NAME));
333    if (!buf)
334        return NULL;
335
336    read_lock_bh(&tipc_net_lock);
337    for (i = 0, m_ptr = media_list; i < media_count; i++, m_ptr++) {
338        for (j = 0; j < MAX_BEARERS; j++) {
339            b_ptr = &tipc_bearers[j];
340            if (b_ptr->active && (b_ptr->media == m_ptr)) {
341                tipc_cfg_append_tlv(buf, TIPC_TLV_BEARER_NAME,
342                            b_ptr->publ.name,
343                            strlen(b_ptr->publ.name) + 1);
344            }
345        }
346    }
347    read_unlock_bh(&tipc_net_lock);
348    return buf;
349}
350
351void tipc_bearer_add_dest(struct bearer *b_ptr, u32 dest)
352{
353    tipc_nmap_add(&b_ptr->nodes, dest);
354    tipc_disc_update_link_req(b_ptr->link_req);
355    tipc_bcbearer_sort();
356}
357
358void tipc_bearer_remove_dest(struct bearer *b_ptr, u32 dest)
359{
360    tipc_nmap_remove(&b_ptr->nodes, dest);
361    tipc_disc_update_link_req(b_ptr->link_req);
362    tipc_bcbearer_sort();
363}
364
365/*
366 * bearer_push(): Resolve bearer congestion. Force the waiting
367 * links to push out their unsent packets, one packet per link
368 * per iteration, until all packets are gone or congestion reoccurs.
369 * 'tipc_net_lock' is read_locked when this function is called
370 * bearer.lock must be taken before calling
371 * Returns binary true(1) ore false(0)
372 */
373static int bearer_push(struct bearer *b_ptr)
374{
375    u32 res = 0;
376    struct link *ln, *tln;
377
378    if (b_ptr->publ.blocked)
379        return 0;
380
381    while (!list_empty(&b_ptr->cong_links) && (res != PUSH_FAILED)) {
382        list_for_each_entry_safe(ln, tln, &b_ptr->cong_links, link_list) {
383            res = tipc_link_push_packet(ln);
384            if (res == PUSH_FAILED)
385                break;
386            if (res == PUSH_FINISHED)
387                list_move_tail(&ln->link_list, &b_ptr->links);
388        }
389    }
390    return list_empty(&b_ptr->cong_links);
391}
392
393void tipc_bearer_lock_push(struct bearer *b_ptr)
394{
395    int res;
396
397    spin_lock_bh(&b_ptr->publ.lock);
398    res = bearer_push(b_ptr);
399    spin_unlock_bh(&b_ptr->publ.lock);
400    if (res)
401        tipc_bcbearer_push();
402}
403
404
405/*
406 * Interrupt enabling new requests after bearer congestion or blocking:
407 * See bearer_send().
408 */
409void tipc_continue(struct tipc_bearer *tb_ptr)
410{
411    struct bearer *b_ptr = (struct bearer *)tb_ptr;
412
413    spin_lock_bh(&b_ptr->publ.lock);
414    b_ptr->continue_count++;
415    if (!list_empty(&b_ptr->cong_links))
416        tipc_k_signal((Handler)tipc_bearer_lock_push, (unsigned long)b_ptr);
417    b_ptr->publ.blocked = 0;
418    spin_unlock_bh(&b_ptr->publ.lock);
419}
420
421/*
422 * Schedule link for sending of messages after the bearer
423 * has been deblocked by 'continue()'. This method is called
424 * when somebody tries to send a message via this link while
425 * the bearer is congested. 'tipc_net_lock' is in read_lock here
426 * bearer.lock is busy
427 */
428
429static void tipc_bearer_schedule_unlocked(struct bearer *b_ptr, struct link *l_ptr)
430{
431    list_move_tail(&l_ptr->link_list, &b_ptr->cong_links);
432}
433
434/*
435 * Schedule link for sending of messages after the bearer
436 * has been deblocked by 'continue()'. This method is called
437 * when somebody tries to send a message via this link while
438 * the bearer is congested. 'tipc_net_lock' is in read_lock here,
439 * bearer.lock is free
440 */
441
442void tipc_bearer_schedule(struct bearer *b_ptr, struct link *l_ptr)
443{
444    spin_lock_bh(&b_ptr->publ.lock);
445    tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
446    spin_unlock_bh(&b_ptr->publ.lock);
447}
448
449
450/*
451 * tipc_bearer_resolve_congestion(): Check if there is bearer congestion,
452 * and if there is, try to resolve it before returning.
453 * 'tipc_net_lock' is read_locked when this function is called
454 */
455int tipc_bearer_resolve_congestion(struct bearer *b_ptr, struct link *l_ptr)
456{
457    int res = 1;
458
459    if (list_empty(&b_ptr->cong_links))
460        return 1;
461    spin_lock_bh(&b_ptr->publ.lock);
462    if (!bearer_push(b_ptr)) {
463        tipc_bearer_schedule_unlocked(b_ptr, l_ptr);
464        res = 0;
465    }
466    spin_unlock_bh(&b_ptr->publ.lock);
467    return res;
468}
469
470/**
471 * tipc_bearer_congested - determines if bearer is currently congested
472 */
473
474int tipc_bearer_congested(struct bearer *b_ptr, struct link *l_ptr)
475{
476    if (unlikely(b_ptr->publ.blocked))
477        return 1;
478    if (likely(list_empty(&b_ptr->cong_links)))
479        return 0;
480    return !tipc_bearer_resolve_congestion(b_ptr, l_ptr);
481}
482
483/**
484 * tipc_enable_bearer - enable bearer with the given name
485 */
486
487int tipc_enable_bearer(const char *name, u32 bcast_scope, u32 priority)
488{
489    struct bearer *b_ptr;
490    struct media *m_ptr;
491    struct bearer_name b_name;
492    char addr_string[16];
493    u32 bearer_id;
494    u32 with_this_prio;
495    u32 i;
496    int res = -EINVAL;
497
498    if (tipc_mode != TIPC_NET_MODE) {
499        warn("Bearer <%s> rejected, not supported in standalone mode\n",
500             name);
501        return -ENOPROTOOPT;
502    }
503    if (!bearer_name_validate(name, &b_name)) {
504        warn("Bearer <%s> rejected, illegal name\n", name);
505        return -EINVAL;
506    }
507    if (!tipc_addr_domain_valid(bcast_scope) ||
508        !tipc_in_scope(bcast_scope, tipc_own_addr)) {
509        warn("Bearer <%s> rejected, illegal broadcast scope\n", name);
510        return -EINVAL;
511    }
512    if ((priority < TIPC_MIN_LINK_PRI ||
513         priority > TIPC_MAX_LINK_PRI) &&
514        (priority != TIPC_MEDIA_LINK_PRI)) {
515        warn("Bearer <%s> rejected, illegal priority\n", name);
516        return -EINVAL;
517    }
518
519    write_lock_bh(&tipc_net_lock);
520
521    m_ptr = media_find(b_name.media_name);
522    if (!m_ptr) {
523        warn("Bearer <%s> rejected, media <%s> not registered\n", name,
524             b_name.media_name);
525        goto failed;
526    }
527
528    if (priority == TIPC_MEDIA_LINK_PRI)
529        priority = m_ptr->priority;
530
531restart:
532    bearer_id = MAX_BEARERS;
533    with_this_prio = 1;
534    for (i = MAX_BEARERS; i-- != 0; ) {
535        if (!tipc_bearers[i].active) {
536            bearer_id = i;
537            continue;
538        }
539        if (!strcmp(name, tipc_bearers[i].publ.name)) {
540            warn("Bearer <%s> rejected, already enabled\n", name);
541            goto failed;
542        }
543        if ((tipc_bearers[i].priority == priority) &&
544            (++with_this_prio > 2)) {
545            if (priority-- == 0) {
546                warn("Bearer <%s> rejected, duplicate priority\n",
547                     name);
548                goto failed;
549            }
550            warn("Bearer <%s> priority adjustment required %u->%u\n",
551                 name, priority + 1, priority);
552            goto restart;
553        }
554    }
555    if (bearer_id >= MAX_BEARERS) {
556        warn("Bearer <%s> rejected, bearer limit reached (%u)\n",
557             name, MAX_BEARERS);
558        goto failed;
559    }
560
561    b_ptr = &tipc_bearers[bearer_id];
562    memset(b_ptr, 0, sizeof(struct bearer));
563
564    strcpy(b_ptr->publ.name, name);
565    res = m_ptr->enable_bearer(&b_ptr->publ);
566    if (res) {
567        warn("Bearer <%s> rejected, enable failure (%d)\n", name, -res);
568        goto failed;
569    }
570
571    b_ptr->identity = bearer_id;
572    b_ptr->media = m_ptr;
573    b_ptr->net_plane = bearer_id + 'A';
574    b_ptr->active = 1;
575    b_ptr->detect_scope = bcast_scope;
576    b_ptr->priority = priority;
577    INIT_LIST_HEAD(&b_ptr->cong_links);
578    INIT_LIST_HEAD(&b_ptr->links);
579    if (m_ptr->bcast) {
580        b_ptr->link_req = tipc_disc_init_link_req(b_ptr, &m_ptr->bcast_addr,
581                              bcast_scope, 2);
582    }
583    spin_lock_init(&b_ptr->publ.lock);
584    write_unlock_bh(&tipc_net_lock);
585    info("Enabled bearer <%s>, discovery domain %s, priority %u\n",
586         name, tipc_addr_string_fill(addr_string, bcast_scope), priority);
587    return 0;
588failed:
589    write_unlock_bh(&tipc_net_lock);
590    return res;
591}
592
593/**
594 * tipc_block_bearer(): Block the bearer with the given name,
595 * and reset all its links
596 */
597
598int tipc_block_bearer(const char *name)
599{
600    struct bearer *b_ptr = NULL;
601    struct link *l_ptr;
602    struct link *temp_l_ptr;
603
604    read_lock_bh(&tipc_net_lock);
605    b_ptr = bearer_find(name);
606    if (!b_ptr) {
607        warn("Attempt to block unknown bearer <%s>\n", name);
608        read_unlock_bh(&tipc_net_lock);
609        return -EINVAL;
610    }
611
612    info("Blocking bearer <%s>\n", name);
613    spin_lock_bh(&b_ptr->publ.lock);
614    b_ptr->publ.blocked = 1;
615    list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
616        struct tipc_node *n_ptr = l_ptr->owner;
617
618        spin_lock_bh(&n_ptr->lock);
619        tipc_link_reset(l_ptr);
620        spin_unlock_bh(&n_ptr->lock);
621    }
622    spin_unlock_bh(&b_ptr->publ.lock);
623    read_unlock_bh(&tipc_net_lock);
624    return 0;
625}
626
627/**
628 * bearer_disable -
629 *
630 * Note: This routine assumes caller holds tipc_net_lock.
631 */
632
633static int bearer_disable(const char *name)
634{
635    struct bearer *b_ptr;
636    struct link *l_ptr;
637    struct link *temp_l_ptr;
638
639    b_ptr = bearer_find(name);
640    if (!b_ptr) {
641        warn("Attempt to disable unknown bearer <%s>\n", name);
642        return -EINVAL;
643    }
644
645    info("Disabling bearer <%s>\n", name);
646    tipc_disc_stop_link_req(b_ptr->link_req);
647    spin_lock_bh(&b_ptr->publ.lock);
648    b_ptr->link_req = NULL;
649    b_ptr->publ.blocked = 1;
650    if (b_ptr->media->disable_bearer) {
651        spin_unlock_bh(&b_ptr->publ.lock);
652        write_unlock_bh(&tipc_net_lock);
653        b_ptr->media->disable_bearer(&b_ptr->publ);
654        write_lock_bh(&tipc_net_lock);
655        spin_lock_bh(&b_ptr->publ.lock);
656    }
657    list_for_each_entry_safe(l_ptr, temp_l_ptr, &b_ptr->links, link_list) {
658        tipc_link_delete(l_ptr);
659    }
660    spin_unlock_bh(&b_ptr->publ.lock);
661    memset(b_ptr, 0, sizeof(struct bearer));
662    return 0;
663}
664
665int tipc_disable_bearer(const char *name)
666{
667    int res;
668
669    write_lock_bh(&tipc_net_lock);
670    res = bearer_disable(name);
671    write_unlock_bh(&tipc_net_lock);
672    return res;
673}
674
675
676
677void tipc_bearer_stop(void)
678{
679    u32 i;
680
681    for (i = 0; i < MAX_BEARERS; i++) {
682        if (tipc_bearers[i].active)
683            tipc_bearers[i].publ.blocked = 1;
684    }
685    for (i = 0; i < MAX_BEARERS; i++) {
686        if (tipc_bearers[i].active)
687            bearer_disable(tipc_bearers[i].publ.name);
688    }
689    media_count = 0;
690}
691
692
693

Archive Download this file



interactive