1 /* 2 * Copyright 2019 Google Inc. 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 #include "net.hpp" 18 19 #include "data.hpp" 20 #include "flags.hpp" 21 22 #include <errno.h> 23 #include <fcntl.h> 24 #include <netdb.h> 25 #include <sys/sendfile.h> 26 #include <sys/socket.h> 27 #include <sys/types.h> 28 29 #include <ipmiblob/blob_errors.hpp> 30 #include <stdplus/handle/managed.hpp> 31 32 #include <cstdint> 33 #include <cstring> 34 #include <memory> 35 #include <optional> 36 #include <string> 37 #include <vector> 38 39 namespace 40 { 41 42 void closefd(int&& fd, const internal::Sys*& sys) 43 { 44 sys->close(fd); 45 } 46 using Fd = stdplus::Managed<int, const internal::Sys*>::Handle<closefd>; 47 48 } // namespace 49 50 namespace host_tool 51 { 52 53 bool NetDataHandler::sendContents(const std::string& input, 54 std::uint16_t session) 55 { 56 constexpr size_t blockSize = 64 * 1024; 57 Fd inputFd(std::nullopt, sys); 58 59 inputFd.reset(sys->open(input.c_str(), O_RDONLY)); 60 if (*inputFd < 0) 61 { 62 (void)inputFd.release(); 63 std::fprintf(stderr, "Unable to open file: '%s'\n", input.c_str()); 64 return false; 65 } 66 67 std::int64_t fileSize = sys->getSize(input.c_str()); 68 if (fileSize == 0) 69 { 70 std::fprintf(stderr, "Zero-length file, or other file access error\n"); 71 return false; 72 } 73 74 Fd connFd(std::nullopt, sys); 75 76 { 77 struct addrinfo hints; 78 std::memset(&hints, 0, sizeof(hints)); 79 hints.ai_flags = AI_NUMERICHOST; 80 hints.ai_family = AF_UNSPEC; 81 hints.ai_socktype = SOCK_STREAM; 82 83 struct addrinfo *addrs, *addr; 84 int ret = sys->getaddrinfo(host.c_str(), port.c_str(), &hints, &addrs); 85 if (ret < 0) 86 { 87 std::fprintf(stderr, "Couldn't parse address %s with port %s: %s\n", 88 host.c_str(), port.c_str(), gai_strerror(ret)); 89 return false; 90 } 91 92 for (addr = addrs; addr != nullptr; addr = addr->ai_next) 93 { 94 connFd.reset(sys->socket(addr->ai_family, addr->ai_socktype, 95 addr->ai_protocol)); 96 if (*connFd == -1) 97 continue; 98 99 if (sys->connect(*connFd, addr->ai_addr, addr->ai_addrlen) != -1) 100 break; 101 } 102 103 // TODO: use stdplus Managed for the addrinfo structs 104 sys->freeaddrinfo(addrs); 105 106 if (addr == nullptr) 107 { 108 std::fprintf(stderr, "Failed to connect\n"); 109 return false; 110 } 111 } 112 113 try 114 { 115 int bytesSent = 0; 116 off_t offset = 0; 117 118 progress->start(fileSize); 119 120 do 121 { 122 bytesSent = sys->sendfile(*connFd, *inputFd, &offset, blockSize); 123 if (bytesSent < 0) 124 { 125 std::fprintf(stderr, "Failed to send data to BMC: %s\n", 126 strerror(errno)); 127 progress->abort(); 128 return false; 129 } 130 else if (bytesSent > 0) 131 { 132 /* Ok, so the data is staged, now send the blob write with 133 * the details. 134 */ 135 struct ipmi_flash::ExtChunkHdr chunk; 136 chunk.length = bytesSent; 137 std::vector<std::uint8_t> chunkBytes(sizeof(chunk)); 138 std::memcpy(chunkBytes.data(), &chunk, sizeof(chunk)); 139 140 /* This doesn't return anything on success. */ 141 blob->writeBytes(session, offset - bytesSent, chunkBytes); 142 progress->updateProgress(bytesSent); 143 } 144 } while (bytesSent > 0); 145 } 146 catch (const ipmiblob::BlobException& b) 147 { 148 progress->abort(); 149 return false; 150 } 151 152 progress->finish(); 153 return true; 154 } 155 156 } // namespace host_tool 157