TypedMsgHdr.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
/* DEBUG: section 54    Interprocess Communication */
 
#ifndef SQUID_SRC_IPC_TYPEDMSGHDR_H
#define SQUID_SRC_IPC_TYPEDMSGHDR_H
 
#include "compat/cmsg.h"
#include "ipc/Messages.h"
#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#if HAVE_SYS_UIO_H
#include <sys/uio.h>
#endif
#if HAVE_SYS_UN_H
#include <sys/un.h>
#endif
 
#include <type_traits>
 
class String;
 
namespace Ipc
{
 
class TypedMsgHdr: public msghdr
{
public:
    enum {maxSize = 4096};
 
public:
    TypedMsgHdr();
    TypedMsgHdr(const TypedMsgHdr &tmh);
    TypedMsgHdr &operator =(const TypedMsgHdr &tmh);
 
    void address(const struct sockaddr_un &addr); 
 
    /* message type manipulation; these must be called before put/get*() */
    void setType(int aType); 
    void checkType(int aType) const; 
    int rawType() const { return msg_iov ? data.type_ : 0; }
 
    /* access for TriviallyCopyable (a.k.a. Plain Old Data or POD) message parts */
    template <class Pod> void getPod(Pod &pod) const; 
    template <class Pod> void putPod(const Pod &pod); 
 
    /* access to message parts for selected commonly-used part types */
    void getString(String &s) const; 
    void putString(const String &s); 
    int getInt() const; 
    void putInt(int n); 
    void getFixed(void *raw, size_t size) const; 
    void putFixed(const void *raw, size_t size); 
 
    bool hasMoreData() const { return offset < data.size; }
 
    /* access to a "file" descriptor that can be passed between processes */
    void putFd(int aFd); 
    int getFd() const; 
    bool hasFd() const; 
 
    /* raw, type-independent access for I/O */
    void prepForReading(); 
    char *raw() { return reinterpret_cast<char*>(this); }
    const char *raw() const { return reinterpret_cast<const char*>(this); }
    size_t size() const { return sizeof(*this); } 
 
private:
    void clear();
    void sync();
    void allocData();
    void allocName();
    void allocControl();
 
    /* raw, type-independent manipulation used by type-specific methods */
    void getRaw(void *raw, size_t size) const;
    void putRaw(const void *raw, size_t size);
 
private:
    struct sockaddr_un name; 
 
    struct iovec ios[1]; 
 
    struct DataBuffer {
        DataBuffer() { memset(raw, 0, sizeof(raw)); }
 
        int type_ = 0; 
        size_t size = 0; 
        char raw[maxSize]; 
    } data; 
 
    struct CtrlBuffer {
        CtrlBuffer() { memset(raw, 0, sizeof(raw)); }
 
        char raw[SQUID_CMSG_SPACE(sizeof(int))];
    } ctrl; 
 
    mutable unsigned int offset = 0;
};
 
} // namespace Ipc
 
template <class Pod>
void
Ipc::TypedMsgHdr::getPod(Pod &pod) const
{
    static_assert(std::is_trivially_copyable<Pod>::value, "getPod() used for a POD");
    getFixed(&pod, sizeof(pod));
}
 
template <class Pod>
void
Ipc::TypedMsgHdr::putPod(const Pod &pod)
{
    static_assert(std::is_trivially_copyable<Pod>::value, "putPod() used for a POD");
    putFixed(&pod, sizeof(pod));
}
 
#endif /* SQUID_SRC_IPC_TYPEDMSGHDR_H */