Differential D6709 Diff 18502 src/ioslaves/file/sharefd.cpp

Changeset View

Standalone View

View Options

src/ioslaves/file/sharefd.cpp

  • This file was added.
1​/***
2​ Copyright (C) 2017 by Chinmoy Ranjan Pradhan <chinmoyrp65@gmail.com>
3​
4​ This library is free software; you can redistribute it and/or
5​ modify it under the terms of the GNU Lesser General Public
6​ License as published by the Free Software Foundation; either
7​ version 2.1 of the License, or (at your option) version 3, or any
8​ later version accepted by the membership of KDE e.V. (or its
9​ successor approved by the membership of KDE e.V.), which shall
10​ act as a proxy defined in Section 6 of version 3 of the license.
11​
12​ This library is distributed in the hope that it will be useful,
13​ but WITHOUT ANY WARRANTY; without even the implied warranty of
14​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15​ Lesser General Public License for more details.
16​
17​ You should have received a copy of the GNU Lesser General Public
18​ License along with this library. If not, see <http://www.gnu.org/licenses/>.
19​***/
20​
21​#include <fcntl.h>
22​#include <unistd.h>
23​#include <sys/socket.h>
24​#include <sys/un.h>
25​#include <string.h>
26​#include <iostream>
27​
28​#include <QSocketNotifier>
29​
30​#include "sharefd.h"
31​
32​//borrowed from klocalsocket.cpp
dfaureUnsubmitted
Done

Either move it to a common header (if QString everywhere is OK), or use a different classname here, to avoid a classname clash at runtime (and document that it was ported to std::string, so we know why it was forked)

dfaure: Either move it to a common header (if QString everywhere is OK), or use a different classname…
33​class KSockaddrUn
34​{
35​ const sockaddr_un addr;
36​
37​public:
38​ KSockaddrUn(const std::string &path)
39​ : addr(make_address(path))
40​ {
41​ }
42​
43​ int length() const
44​ {
45​ return sizeof addr;
46​ }
47​ const sockaddr *address() const
48​ {
49​ return reinterpret_cast<const sockaddr*>(&addr);
50​ }
51​
52​private:
53​ static sockaddr_un make_address(const std::string& path)
54​ {
55​ sockaddr_un a{ AF_UNIX, {0}};
56​ std::string finalPath = "/tmp/" + path;
57​#ifdef __linux__
58​ ::strcpy(&a.sun_path[1], finalPath.c_str());
59​#else
60​ ::strcpy(&a.sun_path, finalPath.c_str());
61​ ::unlink(finalPath.c_str());
62​#endif
63​ return a;
64​ }
65​};
66​
67​class KMsgHdr
dfaureUnsubmitted
Not Done

Can you make the classname more descriptive? ShareFDMessageHeader maybe?
From the looks of it I initially thought this came from kio and not just from sharefd.*

dfaure: Can you make the classname more descriptive? ShareFDMessageHeader maybe? From the looks of it I…
68​{
69​ char io_buf[2];
70​ char cmsg_buf[CMSG_SPACE(sizeof(int))];
71​ iovec io;
72​ msghdr msg;
73​
74​public:
75​ KMsgHdr()
76​ : io_buf{0}
77​ , cmsg_buf{0}
78​ , io{io_buf, sizeof io_buf}
79​ , msg{nullptr, 0, &io, 1, &cmsg_buf, sizeof cmsg_buf, 0}
80​ {
81​ }
82​
83​ msghdr *message()
84​ {
85​ return &msg;
86​ }
87​
88​ cmsghdr *cmsgHeader()
89​ {
90​ return CMSG_FIRSTHDR(&msg);
91​ }
92​};
93​
94​
95​// File descriptor reciever
dfaureUnsubmitted
Not Done

typo: receiver

dfaure: typo: receiver
96​FdReceiver::FdReceiver(const QString &path, QObject *parent)
97​ : QObject(parent)
98​ , m_readNotifier(nullptr)
99​ , m_socketDes(-1)
100​ , m_fileDes(-1)
101​{
102​ m_socketDes = ::socket(AF_LOCAL, SOCK_STREAM|SOCK_NONBLOCK, 0);
103​ if (m_socketDes == -1) {
104​ std::cerr << "socket error:" << strerror(errno);
105​ return;
106​ }
107​
108​ const KSockaddrUn addr(path.toStdString());
davidedmundsonUnsubmitted
Done

If this is on the client side, what stops any other (non authorised) client listening to here?

davidedmundson: If this is on the client side, what stops any other (non authorised) client listening to here?
chinmoyrAuthorUnsubmitted
Done

It doesn't matter. The job of client is to send the file descriptor and any other (unauthorised) client connected cannot see this fd.

chinmoyr: It doesn't matter. The job of client is to send the file descriptor and any other…
109​ if (bind(m_socketDes, addr.address(), addr.length()) < 0 || listen(m_socketDes, 5) < 0) {
110​ std::cerr << "bind/listen error:" << strerror(errno);
111​ ::close(m_socketDes);
112​ m_socketDes = -1;
113​ return;
thiagoUnsubmitted
Done

If SOCK_NONBLOCK is defined, OR it o SOCK_STREAM and then you don't have call setNonBlocking below.

thiago: If SOCK_NONBLOCK is defined, OR it o SOCK_STREAM and then you don't have call setNonBlocking…
114​ }
115​
116​ m_readNotifier = new QSocketNotifier(m_socketDes, QSocketNotifier::Read, this);
117​ connect(m_readNotifier, &QSocketNotifier::activated, this, &FdReceiver::receiveFileDescriptor);
118​}
thiagoUnsubmitted
Done

"binded" is not English. You mean "bound".

thiago: "binded" is not English. You mean "bound".
119​
120​FdReceiver::~FdReceiver()
121​{
122​ if (m_socketDes >= 0) {
123​ ::close(m_socketDes);
124​ }
125​}
126​
127​bool FdReceiver::isValid() const
128​{
129​ return m_socketDes >= 0;
130​}
131​
132​void FdReceiver::receiveFileDescriptor()
133​{
134​ int client = ::accept(m_socketDes, NULL, NULL);
135​ if (client > 0) {
136​ KMsgHdr msg;
137​ if (::recvmsg(client, msg.message(), 0) == 2) {
138​ ::memcpy(&m_fileDes, CMSG_DATA(msg.cmsgHeader()), sizeof m_fileDes);
139​ stopListening();
140​ }
141​ ::close(client);
142​ }
143​}
144​
145​void FdReceiver::stopListening()
146​{
147​ if (m_readNotifier) {
dfaureUnsubmitted
Not Done

this if() serves no purpose (delete nullptr is a well-defined no-op)

dfaure: this if() serves no purpose (delete nullptr is a well-defined no-op)
148​ delete m_readNotifier;
149​ m_readNotifier = nullptr;
150​ }
151​}
152​
153​int FdReceiver::fileDescriptor() const
154​{
155​ return m_fileDes;
156​}
157​
158​
159​// File descriptor sender
dfaureUnsubmitted
Not Done

If FDSender is only used in the kauthhelper, and FDReceiver is only used in kio_file, why not split up this .cpp into two, and only compile the bit that's needed by each target?
(you'll need a private header for the shared classes of course, i.e. the sockaddr wrapper and the messageheader would go into sharefd_p.h)

It would also make the QString vs std::string API difference look less weird.

And then the files can match the classnames, too (fdsender.cpp/h and fdreceiver.cpp/h)

dfaure: If FDSender is only used in the kauthhelper, and FDReceiver is only used in kio_file, why not…
160​FdSender::FdSender(const std::string &path)
161​ : m_socketDes(-1)
162​ , m_connected(false)
163​{
164​ m_socketDes = ::socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0);
165​ if (m_socketDes == -1) {
166​ std::cerr << "socket error:" << strerror(errno);
dfaureUnsubmitted
Not Done

you need std::endl when using std::cerr (repeats)

dfaure: you need std::endl when using std::cerr (repeats)
167​ return;
168​ }
169​
170​ KSockaddrUn addr(path);
171​ if (::connect(m_socketDes, addr.address(), addr.length()) != 0) {
172​ std::cerr << "connection error:" << strerror(errno);
173​ return;
174​ }
175​
176​ m_connected = true;
177​}
178​
179​FdSender::~FdSender()
180​{
181​ if (m_socketDes >= 0) {
182​ ::close(m_socketDes);
183​ }
184​}
185​
186​bool FdSender::sendFileDescriptor(int fd)
187​{
188​ KMsgHdr msg;
189​ cmsghdr *cmsg = msg.cmsgHeader();
190​ cmsg->cmsg_len = CMSG_LEN(sizeof(int));
191​ cmsg->cmsg_type = SCM_RIGHTS;
192​ cmsg->cmsg_level = SOL_SOCKET;
193​ memcpy(CMSG_DATA(cmsg), &fd, sizeof fd);
194​ bool success = sendmsg(m_socketDes, msg.message(), 0) == 2;
195​ ::close(m_socketDes);
196​ return success;
197​}
198​
199​bool FdSender::isConnected() const
200​{
201​ return m_connected;
202​}