blob: 3908020a12cbc38e4ec6bad470825080a0e81787 [file] [log] [blame]
Colin Crossa3d386e2013-02-06 21:03:34 -08001/*
2 * Copyright (c) 2009-2013, Google Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the
13 * distribution.
14 * * Neither the name of Google, Inc. nor the names of its contributors
15 * may be used to endorse or promote products derived from this
16 * software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
25 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
26 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
27 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
28 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <stddef.h>
33#include <stdio.h>
34#include <stdlib.h>
35#include <string.h>
36
37#include "debug.h"
38#include "protocol.h"
39#include "transport.h"
40
41#define STATE_OFFLINE 0
42#define STATE_COMMAND 1
43#define STATE_COMPLETE 2
44#define STATE_ERROR 3
45
46struct fastboot_cmd {
47 struct fastboot_cmd *next;
48 const char *prefix;
49 unsigned prefix_len;
50 void (*execute)(struct protocol_handle *phandle, const char *arg);
51};
52
53struct fastboot_var {
54 struct fastboot_var *next;
55 const char *name;
56 const char *value;
57};
58
59static struct fastboot_cmd *cmdlist;
60
61void fastboot_register(const char *prefix,
62 void (*phandle)(struct protocol_handle *phandle, const char *arg))
63{
64 struct fastboot_cmd *cmd;
65 cmd = malloc(sizeof(*cmd));
66 if (cmd) {
67 cmd->prefix = prefix;
68 cmd->prefix_len = strlen(prefix);
69 cmd->execute = phandle;
70 cmd->next = cmdlist;
71 cmdlist = cmd;
72 }
73}
74
75static struct fastboot_var *varlist;
76
77void fastboot_publish(const char *name, const char *value)
78{
79 struct fastboot_var *var;
80 var = malloc(sizeof(*var));
81 if (var) {
82 var->name = name;
83 var->value = value;
84 var->next = varlist;
85 varlist = var;
86 }
87}
88
89const char *fastboot_getvar(const char *name)
90{
91 struct fastboot_var *var;
92
93 for (var = varlist; var; var = var->next) {
94 if (!strcmp(var->name, name)) {
95 return var->value;
96 }
97 }
98
99 return "";
100}
101
102int protocol_handle_download(struct protocol_handle *phandle, size_t len)
103{
104 return transport_handle_download(phandle->transport_handle, len);
105}
106
107static ssize_t protocol_handle_write(struct protocol_handle *phandle,
108 char *buffer, size_t len)
109{
110 return transport_handle_write(phandle->transport_handle, buffer, len);
111}
112
113static void fastboot_ack(struct protocol_handle *phandle, const char *code,
114 const char *reason)
115{
116 char response[64];
117
118 if (phandle->state != STATE_COMMAND)
119 return;
120
121 if (reason == 0)
122 reason = "";
123
124 snprintf(response, 64, "%s%s", code, reason);
125 phandle->state = STATE_COMPLETE;
126
127 protocol_handle_write(phandle, response, strlen(response));
128}
129
130void fastboot_fail(struct protocol_handle *phandle, const char *reason)
131{
132 fastboot_ack(phandle, "FAIL", reason);
133}
134
135void fastboot_okay(struct protocol_handle *phandle, const char *info)
136{
137 fastboot_ack(phandle, "OKAY", info);
138}
139
140void fastboot_data(struct protocol_handle *phandle, size_t len)
141{
142 char response[64];
143 ssize_t ret;
144
Elliott Hughes5d9fe772014-02-05 17:50:35 -0800145 snprintf(response, 64, "DATA%08zx", len);
Colin Crossa3d386e2013-02-06 21:03:34 -0800146 ret = protocol_handle_write(phandle, response, strlen(response));
147 if (ret < 0)
148 return;
149}
150
151void protocol_handle_command(struct protocol_handle *phandle, char *buffer)
152{
153 D(INFO,"fastboot: %s\n", buffer);
154
155 struct fastboot_cmd *cmd;
156
157 for (cmd = cmdlist; cmd; cmd = cmd->next) {
158 if (memcmp(buffer, cmd->prefix, cmd->prefix_len))
159 continue;
160 phandle->state = STATE_COMMAND;
161 cmd->execute(phandle, buffer + cmd->prefix_len);
162 if (phandle->state == STATE_COMMAND)
163 fastboot_fail(phandle, "unknown reason");
164 return;
165 }
166
167 fastboot_fail(phandle, "unknown command");
168}
169
170struct protocol_handle *create_protocol_handle(struct transport_handle *thandle)
171{
172 struct protocol_handle *phandle;
173
174 phandle = calloc(sizeof(struct protocol_handle), 1);
175
176 phandle->transport_handle = thandle;
177 phandle->state = STATE_OFFLINE;
178 phandle->download_fd = -1;
179
180 pthread_mutex_init(&phandle->lock, NULL);
181
182 return phandle;
183}
184
185int protocol_get_download(struct protocol_handle *phandle)
186{
187 int fd;
188
189 pthread_mutex_lock(&phandle->lock);
190 fd = phandle->download_fd;
191 phandle->download_fd = -1;
192 pthread_mutex_unlock(&phandle->lock);
193
194 return fd;
195}