1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef __ADB_SOCKET_H
18#define __ADB_SOCKET_H
19
20#include <stddef.h>
21
22#include <deque>
23#include <memory>
24#include <string>
25
26#include "fdevent.h"
27#include "range.h"
28
29struct apacket;
30class atransport;
31
32/* An asocket represents one half of a connection between a local and
33 * remote entity.  A local asocket is bound to a file descriptor.  A
34 * remote asocket is bound to the protocol engine.
35 */
36struct asocket {
37    /* the unique identifier for this asocket
38     */
39    unsigned id = 0;
40
41    /* flag: set when the socket's peer has closed
42     * but packets are still queued for delivery
43     */
44    int closing = 0;
45
46    // flag: set when the socket failed to write, so the socket will not wait to
47    // write packets and close directly.
48    bool has_write_error = 0;
49
50    /* flag: quit adbd when both ends close the
51     * local service socket
52     */
53    int exit_on_close = 0;
54
55    // the asocket we are connected to
56    asocket* peer = nullptr;
57
58    /* For local asockets, the fde is used to bind
59     * us to our fd event system.  For remote asockets
60     * these fields are not used.
61     */
62    fdevent fde = {};
63    int fd = 0;
64
65    // queue of data waiting to be written
66    std::deque<Range> packet_queue;
67
68    std::string smart_socket_data;
69
70    /* enqueue is called by our peer when it has data
71     * for us.  It should return 0 if we can accept more
72     * data or 1 if not.  If we return 1, we must call
73     * peer->ready() when we once again are ready to
74     * receive data.
75     */
76    int (*enqueue)(asocket* s, std::string data) = nullptr;
77
78    /* ready is called by the peer when it is ready for
79     * us to send data via enqueue again
80     */
81    void (*ready)(asocket* s) = nullptr;
82
83    /* shutdown is called by the peer before it goes away.
84     * the socket should not do any further calls on its peer.
85     * Always followed by a call to close. Optional, i.e. can be NULL.
86     */
87    void (*shutdown)(asocket* s) = nullptr;
88
89    /* close is called by the peer when it has gone away.
90     * we are not allowed to make any further calls on the
91     * peer once our close method is called.
92     */
93    void (*close)(asocket* s) = nullptr;
94
95    /* A socket is bound to atransport */
96    atransport* transport = nullptr;
97
98    size_t get_max_payload() const;
99};
100
101asocket *find_local_socket(unsigned local_id, unsigned remote_id);
102void install_local_socket(asocket *s);
103void remove_socket(asocket *s);
104void close_all_sockets(atransport *t);
105
106asocket *create_local_socket(int fd);
107asocket* create_local_service_socket(const char* destination, atransport* transport);
108
109asocket *create_remote_socket(unsigned id, atransport *t);
110void connect_to_remote(asocket *s, const char *destination);
111void connect_to_smartsocket(asocket *s);
112
113// Internal functions that are only made available here for testing purposes.
114namespace internal {
115
116#if ADB_HOST
117char* skip_host_serial(char* service);
118#endif
119
120}  // namespace internal
121
122#endif  // __ADB_SOCKET_H
123