UdsOp.cc
Go to the documentation of this file.
1/*
2 * Copyright (C) 1996-2022 The Squid Software Foundation and contributors
3 *
4 * Squid software is distributed under GPLv2+ license and includes
5 * contributions from numerous individuals and organizations.
6 * Please see the COPYING and CONTRIBUTORS files for details.
7 */
8
9/* DEBUG: section 54 Interprocess Communication */
10
11#include "squid.h"
12#include "base/TextException.h"
13#include "comm.h"
14#include "comm/Connection.h"
15#include "comm/Write.h"
16#include "CommCalls.h"
17#include "ipc/UdsOp.h"
18
19Ipc::UdsOp::UdsOp(const String& pathAddr):
20 AsyncJob("Ipc::UdsOp"),
21 address(PathToAddress(pathAddr)),
22 options(COMM_NONBLOCKING)
23{
24 debugs(54, 5, '[' << this << "] pathAddr=" << pathAddr);
25}
26
28{
29 debugs(54, 5, '[' << this << ']');
30 if (Comm::IsConnOpen(conn_))
31 conn_->close();
32 conn_ = nullptr;
33}
34
35void Ipc::UdsOp::setOptions(int newOptions)
36{
37 options = newOptions;
38}
39
42{
43 if (!Comm::IsConnOpen(conn_)) {
44 if (options & COMM_DOBIND)
45 unlink(address.sun_path);
46 if (conn_ == nullptr)
47 conn_ = new Comm::Connection;
48 conn_->fd = comm_open_uds(SOCK_DGRAM, 0, &address, options);
49 Must(Comm::IsConnOpen(conn_));
50 }
51 return conn_;
52}
53
54void Ipc::UdsOp::setTimeout(int seconds, const char *handlerName)
55{
57 AsyncCall::Pointer handler = asyncCall(54,5, handlerName,
59 commSetConnTimeout(conn(), seconds, handler);
60}
61
63{
65}
66
68{
69 timedout(); // our kid handles communication timeout
70}
71
72struct sockaddr_un
73Ipc::PathToAddress(const String& pathAddr) {
74 assert(pathAddr.size() != 0);
75 struct sockaddr_un unixAddr;
76 memset(&unixAddr, 0, sizeof(unixAddr));
77 unixAddr.sun_family = AF_LOCAL;
78 xstrncpy(unixAddr.sun_path, pathAddr.termedBuf(), sizeof(unixAddr.sun_path));
79 return unixAddr;
80}
81
83
84Ipc::UdsSender::UdsSender(const String& pathAddr, const TypedMsgHdr& aMessage):
85 UdsOp(pathAddr),
86 codeContext(CodeContext::Current()),
87 message(aMessage),
88 retries(10), // TODO: make configurable?
89 timeout(10), // TODO: make configurable?
90 sleeping(false),
91 writing(false)
92{
94}
95
97{
98 // did we abort while waiting between retries?
99 if (sleeping)
100 cancelSleep();
101
103}
104
106{
107 UdsOp::start();
108 write();
109 if (timeout > 0)
110 setTimeout(timeout, "Ipc::UdsSender::noteTimeout");
111}
112
114{
115 return !writing && !sleeping && UdsOp::doneAll();
116}
117
119{
120 debugs(54, 5, MYNAME);
122 AsyncCall::Pointer writeHandler = JobCallback(54, 5,
123 Dialer, this, UdsSender::wrote);
124 Comm::Write(conn(), message.raw(), message.size(), writeHandler, nullptr);
125 writing = true;
126}
127
129{
130 debugs(54, 5, params.conn << " flag " << params.flag << " retries " << retries << " [" << this << ']');
131 writing = false;
132 if (params.flag != Comm::OK && retries-- > 0) {
133 // perhaps a fresh connection and more time will help?
134 conn()->close();
135 startSleep();
136 }
137}
138
141{
142 Must(!sleeping);
143 sleeping = true;
144 eventAdd("Ipc::UdsSender::DelayedRetry",
146 new Pointer(this), 1, 0, false); // TODO: Use Fibonacci increments
147}
148
151{
152 if (sleeping) {
153 // Why not delete the event? See Comm::ConnOpener::cancelSleep().
154 sleeping = false;
155 debugs(54, 9, "stops sleeping");
156 }
157}
158
161{
162 Pointer *ptr = static_cast<Pointer*>(data);
163 assert(ptr);
164 if (UdsSender *us = dynamic_cast<UdsSender*>(ptr->valid())) {
165 CallBack(us->codeContext, [&us] {
166 CallJobHere(54, 4, us, UdsSender, delayedRetry);
167 });
168 }
169 delete ptr;
170}
171
174{
175 debugs(54, 5, sleeping);
176 if (sleeping) {
177 sleeping = false;
178 write(); // reopens the connection if needed
179 }
180}
181
183{
184 debugs(54, 5, MYNAME);
185 mustStop("timedout");
186}
187
188void Ipc::SendMessage(const String& toAddress, const TypedMsgHdr &message)
189{
190 AsyncJob::Start(new UdsSender(toAddress, message));
191}
192
194Ipc::ImportFdIntoComm(const Comm::ConnectionPointer &conn, int socktype, int protocol, Ipc::FdNoteId noteId)
195{
196 struct sockaddr_storage addr;
197 socklen_t len = sizeof(addr);
198 if (getsockname(conn->fd, reinterpret_cast<sockaddr*>(&addr), &len) == 0) {
199 conn->remote = addr;
200 struct addrinfo* addr_info = nullptr;
201 conn->remote.getAddrInfo(addr_info);
202 addr_info->ai_socktype = socktype;
203 addr_info->ai_protocol = protocol;
204 comm_import_opened(conn, Ipc::FdNote(noteId), addr_info);
205 Ip::Address::FreeAddr(addr_info);
206 } else {
207 int xerrno = errno;
208 debugs(54, DBG_CRITICAL, "ERROR: Ipc::ImportFdIntoComm: " << conn << ' ' << xstrerr(xerrno));
209 conn->close();
210 }
211 return conn;
212}
213
AsyncCall * asyncCall(int aDebugSection, int aDebugLevel, const char *aName, const Dialer &aDialer)
Definition: AsyncCall.h:154
#define JobCallback(dbgSection, dbgLevel, Dialer, job, method)
Convenience macro to create a Dialer-based job callback.
Definition: AsyncJobCalls.h:69
void CallBack(const CodeContext::Pointer &callbackContext, Fun &&callback)
Definition: CodeContext.h:112
#define COMM_DOBIND
Definition: Connection.h:49
#define COMM_NONBLOCKING
Definition: Connection.h:46
#define false
Definition: GnuRegex.c:240
#define Must(condition)
Definition: TextException.h:71
int conn
the current server connection FD
Definition: Transport.cc:26
CBDATA_NAMESPACED_CLASS_INIT(Ipc, UdsSender)
#define assert(EX)
Definition: assert.h:19
static int retries
static void Start(const Pointer &job)
Definition: AsyncJob.cc:24
virtual bool doneAll() const
whether positive goal has been reached
Definition: AsyncJob.cc:97
virtual void start()
called by AsyncStart; do not call directly
Definition: AsyncJob.cc:44
virtual void swanSong()
Definition: AsyncJob.h:59
Comm::Flag flag
comm layer result status.
Definition: CommCalls.h:87
Comm::ConnectionPointer conn
Definition: CommCalls.h:85
static void FreeAddr(struct addrinfo *&ai)
Definition: Address.cc:686
struct msghdr with a known type, fixed-size I/O and control buffers
Definition: TypedMsgHdr.h:35
void address(const struct sockaddr_un &addr)
sets [dest.] address
Definition: TypedMsgHdr.cc:85
virtual ~UdsOp()
Definition: UdsOp.cc:27
void noteTimeout(const CommTimeoutCbParams &p)
Comm timeout callback; calls timedout()
Definition: UdsOp.cc:67
void setTimeout(int seconds, const char *handlerName)
call timedout() if no UDS messages in a given number of seconds
Definition: UdsOp.cc:54
UdsOp(const String &pathAddr)
Definition: UdsOp.cc:19
void setOptions(int newOptions)
changes socket options
Definition: UdsOp.cc:35
void clearTimeout()
remove previously set timeout, if any
Definition: UdsOp.cc:62
Comm::ConnectionPointer & conn()
creates if needed and returns raw UDS socket descriptor
Definition: UdsOp.cc:41
struct sockaddr_un address
UDS address from path; treat as read-only.
Definition: UdsOp.h:37
attempts to send an IPC message a few times, with a timeout
Definition: UdsOp.h:69
void cancelSleep()
stop sleeping (or do nothing if we were not)
Definition: UdsOp.cc:150
virtual void swanSong()
Definition: UdsOp.cc:96
virtual void timedout()
called after setTimeout() if timed out
Definition: UdsOp.cc:182
virtual void start()
called by AsyncStart; do not call directly
Definition: UdsOp.cc:105
static void DelayedRetry(void *data)
legacy wrapper for Ipc::UdsSender::delayedRetry()
Definition: UdsOp.cc:160
void delayedRetry()
make another sending attempt after a pause
Definition: UdsOp.cc:173
void startSleep()
pause for a while before resending the message
Definition: UdsOp.cc:140
void wrote(const CommIoCbParams &params)
done writing or error
Definition: UdsOp.cc:128
void write()
schedule writing
Definition: UdsOp.cc:118
TypedMsgHdr message
what to send
Definition: UdsOp.h:93
UdsSender(const String &pathAddr, const TypedMsgHdr &aMessage)
Definition: UdsOp.cc:84
virtual bool doneAll() const
whether positive goal has been reached
Definition: UdsOp.cc:113
#define AF_LOCAL
Definition: cmsg.h:128
int commSetConnTimeout(const Comm::ConnectionPointer &conn, int timeout, AsyncCall::Pointer &callback)
Definition: comm.cc:589
int comm_open_uds(int sock_type, int proto, struct sockaddr_un *addr, int flags)
Create a unix-domain socket (UDS) that only supports FD_MSGHDR I/O.
Definition: comm.cc:1708
void comm_import_opened(const Comm::ConnectionPointer &conn, const char *note, struct addrinfo *AI)
update Comm state after getting a comm_open() FD from another process
Definition: comm.cc:536
int commUnsetConnTimeout(const Comm::ConnectionPointer &conn)
Definition: comm.cc:615
#define MYNAME
Definition: Stream.h:238
#define debugs(SECTION, LEVEL, CONTENT)
Definition: Stream.h:196
#define DBG_CRITICAL
Definition: Stream.h:40
void eventAdd(const char *name, EVH *func, void *arg, double when, int weight, bool cbdata)
Definition: event.cc:107
bool IsConnOpen(const Comm::ConnectionPointer &conn)
Definition: Connection.cc:27
void Write(const Comm::ConnectionPointer &conn, const char *buf, int size, AsyncCall::Pointer &callback, FREE *free_func)
Definition: Write.cc:33
@ OK
Definition: Flag.h:16
Definition: IpcIoFile.h:24
FdNoteId
We cannot send char* FD notes to other processes. Pass int IDs and convert.
Definition: FdNotes.h:20
void SendMessage(const String &toAddress, const TypedMsgHdr &message)
Definition: UdsOp.cc:188
struct sockaddr_un PathToAddress(const String &pathAddr)
converts human-readable filename path into UDS address
Definition: UdsOp.cc:73
const Comm::ConnectionPointer & ImportFdIntoComm(const Comm::ConnectionPointer &conn, int socktype, int protocol, FdNoteId noteId)
import socket fd from another strand into our Comm state
Definition: UdsOp.cc:194
const char * FdNote(int fdNodeId)
converts FdNoteId into a string
Definition: FdNotes.cc:16
SSL Connection
Definition: Session.h:45
static void handler(int signo)
Definition: purge.cc:854
char sun_family
Definition: cmsg.h:107
char sun_path[256]
Definition: cmsg.h:108
int socklen_t
Definition: types.h:158
const char * xstrerr(int error)
Definition: xstrerror.cc:83
char * xstrncpy(char *dst, const char *src, size_t n)
Definition: xstring.cc:37

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors