100% found this document useful (1 vote)
29 views81 pages

94907568

The document provides information about various ebooks available for download, including 'Software Development with Go: Cloud-Native Programming using Golang with Linux and Docker' by Nanik Tolaram. It lists multiple titles along with their ISBNs and links for instant access. Additionally, it includes details about the book's content, structure, and acknowledgments from the author.

Uploaded by

jianafykesfb
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
100% found this document useful (1 vote)
29 views81 pages

94907568

The document provides information about various ebooks available for download, including 'Software Development with Go: Cloud-Native Programming using Golang with Linux and Docker' by Nanik Tolaram. It lists multiple titles along with their ISBNs and links for instant access. Additionally, it includes details about the book's content, structure, and acknowledgments from the author.

Uploaded by

jianafykesfb
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 81

Download the Full Ebook and Access More Features - ebooknice.

com

(Ebook) Software Development with Go: Cloud-Native


Programming using Golang with Linux and Docker by
Nanik Tolaram ISBN 9781484287309, 9781484287316,
1484287304, 1484287312
https://ebooknice.com/product/software-development-with-go-
cloud-native-programming-using-golang-with-linux-and-
docker-47453784

OR CLICK HERE

DOWLOAD EBOOK

Download more ebook instantly today at https://ebooknice.com


Instant digital products (PDF, ePub, MOBI) ready for you
Download now and discover formats that fit your needs...

Start reading on any device today!

(Ebook) Software Development with Go: Cloud-Native


Programming using Golang with Linux and Docker by Nanik
Tolaram ISBN 9781484287316, 9781484287309, 1484287312,
1484287304, 1657331859, 1657331853, 1656239941, 3782993600
https://ebooknice.com/product/software-development-with-go-cloud-
native-programming-using-golang-with-linux-and-docker-50787966

ebooknice.com

(Ebook) Biota Grow 2C gather 2C cook by Loucas, Jason;


Viles, James ISBN 9781459699816, 9781743365571,
9781925268492, 1459699815, 1743365578, 1925268497
https://ebooknice.com/product/biota-grow-2c-gather-2c-cook-6661374

ebooknice.com

(Ebook) Full-Stack Web Development with Go■Build your web


applications quickly using the Go programming language and
Vue.js by Nanik Tolaram, Nick Glynn ISBN B0BBMNXGJX
https://ebooknice.com/product/full-stack-web-development-with-go-
build-your-web-applications-quickly-using-the-go-programming-language-
and-vue-js-55935432
ebooknice.com

(Ebook) Matematik 5000+ Kurs 2c Lärobok by Lena


Alfredsson, Hans Heikne, Sanna Bodemyr ISBN 9789127456600,
9127456609
https://ebooknice.com/product/matematik-5000-kurs-2c-larobok-23848312

ebooknice.com
(Ebook) SAT II Success MATH 1C and 2C 2002 (Peterson's SAT
II Success) by Peterson's ISBN 9780768906677, 0768906679

https://ebooknice.com/product/sat-ii-success-
math-1c-and-2c-2002-peterson-s-sat-ii-success-1722018

ebooknice.com

(Ebook) Network Programming with Go Language : Essential


Skills for Programming, Using and Securing Networks with
Open Source Google Golang by Jan Newmarch; Ronald Petty
ISBN 9781484280959, 1484280954
https://ebooknice.com/product/network-programming-with-go-language-
essential-skills-for-programming-using-and-securing-networks-with-
open-source-google-golang-43739744
ebooknice.com

(Ebook) gRPC: Up and Running: Building Cloud Native


Applications with Go and Java for Docker and Kubernetes by
Kasun Indrasiri, Danesh Kuruppu ISBN 9781492058335,
1492058335, B0845YMM37
https://ebooknice.com/product/grpc-up-and-running-building-cloud-
native-applications-with-go-and-java-for-docker-and-
kubernetes-10690006
ebooknice.com

(Ebook) Cloud Native Development with Google Cloud by


Daniel Vaughan

https://ebooknice.com/product/cloud-native-development-with-google-
cloud-53721370

ebooknice.com

(Ebook) Pro Go: The Complete Guide to Programming Reliable


and Efficient Software Using Golang by Adam Freeman ISBN
9781484273548, 9781484273555, 1484273540, 1484273559
https://ebooknice.com/product/pro-go-the-complete-guide-to-
programming-reliable-and-efficient-software-using-golang-37511492

ebooknice.com
Software Development
with Go
Cloud-Native Programming
using Golang with Linux
and Docker

Nanik Tolaram
Software Development with Go: Cloud-Native Programming using Golang
with Linux and Docker

Nanik Tolaram
Sydney, NSW, Australia

ISBN-13 (pbk): 978-1-4842-8730-9 ISBN-13 (electronic): 978-1-4842-8731-6


https://doi.org/10.1007/978-1-4842-8731-6
Copyright © 2023 by Nanik Tolaram
This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or
part of the material is concerned, specifically the rights of translation, reprinting, reuse of
illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way,
and transmission or information storage and retrieval, electronic adaptation, computer software,
or by similar or dissimilar methodology now known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark
symbol with every occurrence of a trademarked name, logo, or image we use the names, logos,
and images only in an editorial fashion and to the benefit of the trademark owner, with no
intention of infringement of the trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if
they are not identified as such, is not to be taken as an expression of opinion as to whether or not
they are subject to proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of
publication, neither the authors nor the editors nor the publisher can accept any legal
responsibility for any errors or omissions that may be made. The publisher makes no warranty,
express or implied, with respect to the material contained herein.
Managing Director, Apress Media LLC: Welmoed Spahr
Acquisitions Editor: James Robinson-Prior
Development Editor: James Markham
Coordinating Editor: Gryffin Winkler
Copy Editor: Mary Behr
Cover designed by eStudioCalamar
Cover image designed by Freepik (www.freepik.com)
Distributed to the book trade worldwide by Springer Science+Business Media New York, 1
New York Plaza, Suite 4600, New York, NY 10004-1562, USA. Phone 1-800-SPRINGER, fax (201)
348-4505, e-mail [email protected], or visit www.springeronline.com. Apress Media,
LLC is a California LLC and the sole member (owner) is Springer Science + Business Media
Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation.
For information on translations, please e-mail [email protected]; for
reprint, paperback, or audio rights, please e-mail [email protected].
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook
versions and licenses are also available for most titles. For more information, reference our Print
and eBook Bulk Sales web page at www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is
available to readers on GitHub (https://github.com/Apress). For more detailed information,
please visit www.apress.com/source-code.
Printed on acid-free paper
I would like to dedicate this book to my late Dad who stood
by me and encouraged me to write my very first book when
I was 17 years old. To my dearest Mum who always
supported me in pursuing my dreams and encouraged me
to keep on going no matter what life brings. To my beautiful
wife and best friend for allowing me the time to write the
book and supporting me in every step of our life. To both my
sons, Rahul and Manav, for allowing me to spend time in
front of the computer on weekends to chase my dream and
passion. Last but not least, to God for giving me this life and
opportunity to be where I am in this world.
Table of Contents
About the Author�������������������������������������������������������������������������������xiii

About the Technical Reviewer������������������������������������������������������������xv

Acknowledgments����������������������������������������������������������������������������xvii

Introduction���������������������������������������������������������������������������������������xix

Part I: System Programming������������������������������������������������1


Chapter 1: System Calls�����������������������������������������������������������������������3
Source Code����������������������������������������������������������������������������������������������������������3
What Is a System Call?�����������������������������������������������������������������������������������������4
C System Call��������������������������������������������������������������������������������������������������������5
sys/unix Package��������������������������������������������������������������������������������������������������8
System Call in Go������������������������������������������������������������������������������������������������������� 10
Summary������������������������������������������������������������������������������������������������������������14

Chapter 2: System Calls Using Go������������������������������������������������������15


Source Code��������������������������������������������������������������������������������������������������������15
Syscall Package��������������������������������������������������������������������������������������������������16
syscall Application����������������������������������������������������������������������������������������������������� 16
Checking Disk Space������������������������������������������������������������������������������������������������� 18
Webserver with syscall���������������������������������������������������������������������������������������������� 20

v
Table of Contents

ELF Package�������������������������������������������������������������������������������������������������������22
High-Level ELF Format���������������������������������������������������������������������������������������������� 23
Dump Example���������������������������������������������������������������������������������������������������������� 24

/sys Filesystem���������������������������������������������������������������������������������������������������28
Reading AppArmor����������������������������������������������������������������������������������������������������� 29

Summary������������������������������������������������������������������������������������������������������������31

Chapter 3: Accessing proc File System����������������������������������������������33


Source Code��������������������������������������������������������������������������������������������������������33
Peeking Inside procfs������������������������������������������������������������������������������������������34
Reading Memory Information�����������������������������������������������������������������������������38
Peeking Network Information������������������������������������������������������������������������������������ 41

Using the procfs Library��������������������������������������������������������������������������������������44


Code Sample������������������������������������������������������������������������������������������������������������� 44
Inside the procfs Library�������������������������������������������������������������������������������������������� 46

Summary������������������������������������������������������������������������������������������������������������48

Part II: Containers���������������������������������������������������������������49


Chapter 4: Simple Containers�������������������������������������������������������������51
Linux Namespace������������������������������������������������������������������������������������������������51
cgroups���������������������������������������������������������������������������������������������������������������55
rootfs�������������������������������������������������������������������������������������������������������������������58
Gontainer Project������������������������������������������������������������������������������������������������63
Summary������������������������������������������������������������������������������������������������������������70

vi
Table of Contents

Chapter 5: Containers with Networking���������������������������������������������71


Source Code��������������������������������������������������������������������������������������������������������71
Network Namespace������������������������������������������������������������������������������������������������� 72
Setting Up with the ip Tool����������������������������������������������������������������������������������������� 74
Containers with Networks����������������������������������������������������������������������������������������� 79
Summary������������������������������������������������������������������������������������������������������������������� 88

Chapter 6: Docker Security�����������������������������������������������������������������89


Source Code��������������������������������������������������������������������������������������������������������89
seccomp Profiles������������������������������������������������������������������������������������������������89
libseccomp���������������������������������������������������������������������������������������������������������������� 91
Docker seccomp�������������������������������������������������������������������������������������������������������� 95

Docker Proxy�������������������������������������������������������������������������������������������������������98
Container Attack Surface����������������������������������������������������������������������������������105
Summary����������������������������������������������������������������������������������������������������������106

Part III: Application Security��������������������������������������������109


Chapter 7: Gosec and AST����������������������������������������������������������������111
Source Code������������������������������������������������������������������������������������������������������111
Abstract Syntax Tree�����������������������������������������������������������������������������������������111
Modules������������������������������������������������������������������������������������������������������������������� 115
Sample Code����������������������������������������������������������������������������������������������������������� 116

gosec����������������������������������������������������������������������������������������������������������������122
Inside gosec������������������������������������������������������������������������������������������������������������ 123
Rules������������������������������������������������������������������������������������������������������������������������ 128

Summary����������������������������������������������������������������������������������������������������������130

vii
Table of Contents

Chapter 8: Scorecard������������������������������������������������������������������������131
Source Code������������������������������������������������������������������������������������������������������131
What Is Scorecard?�������������������������������������������������������������������������������������������131
Setting Up Scorecard����������������������������������������������������������������������������������������������� 133
Running Scorecard�������������������������������������������������������������������������������������������������� 137
High-Level Flow������������������������������������������������������������������������������������������������������� 139

GitHub���������������������������������������������������������������������������������������������������������������145
GitHub API���������������������������������������������������������������������������������������������������������������� 145
GitHub Explorer�������������������������������������������������������������������������������������������������������� 156

Summary����������������������������������������������������������������������������������������������������������159

Part IV: Networking����������������������������������������������������������161


Chapter 9: Simple Networking����������������������������������������������������������163
Source Code������������������������������������������������������������������������������������������������������163
TCP Networking������������������������������������������������������������������������������������������������163
TCP Client���������������������������������������������������������������������������������������������������������������� 164
TCP Server��������������������������������������������������������������������������������������������������������������� 166

UDP Networking������������������������������������������������������������������������������������������������168
UDP Client���������������������������������������������������������������������������������������������������������������� 169
UDP Server�������������������������������������������������������������������������������������������������������������� 172
Concurrent Servers�������������������������������������������������������������������������������������������������� 174

Load Testing������������������������������������������������������������������������������������������������������175
Summary����������������������������������������������������������������������������������������������������������179

Chapter 10: System Networking�������������������������������������������������������181


Source Code������������������������������������������������������������������������������������������������������181
Ping Utility���������������������������������������������������������������������������������������������������������181
Code Walkthrough��������������������������������������������������������������������������������������������������� 182

viii
Table of Contents

DNS Server��������������������������������������������������������������������������������������������������������188
Running a DNS Server��������������������������������������������������������������������������������������������� 188
DNS Forwarder�������������������������������������������������������������������������������������������������������� 189
Pack and Unpack����������������������������������������������������������������������������������������������������� 193
Summary����������������������������������������������������������������������������������������������������������196

Chapter 11: Google gopacket������������������������������������������������������������199


Source Code������������������������������������������������������������������������������������������������������199
gopacket�����������������������������������������������������������������������������������������������������������200
Layer������������������������������������������������������������������������������������������������������������������������ 200
Packet���������������������������������������������������������������������������������������������������������������������� 204

Using gopacket�������������������������������������������������������������������������������������������������205
pcap������������������������������������������������������������������������������������������������������������������������� 205
Networking Sniffer�������������������������������������������������������������������������������������������������� 206
Capturing With BPF�������������������������������������������������������������������������������������������������� 217

Summary����������������������������������������������������������������������������������������������������������222

Chapter 12: Epoll Library������������������������������������������������������������������223


Source Code������������������������������������������������������������������������������������������������������224
Understanding epoll������������������������������������������������������������������������������������������224
epoll in Golang��������������������������������������������������������������������������������������������������226
Epoll Registration���������������������������������������������������������������������������������������������������� 227
Epoll Wait����������������������������������������������������������������������������������������������������������������� 229

Epoll Library������������������������������������������������������������������������������������������������������232
Summary����������������������������������������������������������������������������������������������������������235

ix
Table of Contents

Part V: Securing Linux������������������������������������������������������239


Chapter 13: Vulnerability Scanner����������������������������������������������������239
Source Code������������������������������������������������������������������������������������������������������239
Vulnerability Scanners��������������������������������������������������������������������������������������240
Using Vuls���������������������������������������������������������������������������������������������������������241
Checking Out the Code�������������������������������������������������������������������������������������������� 241
Running Scan���������������������������������������������������������������������������������������������������������� 243

Learning From Vuls�������������������������������������������������������������������������������������������248


Port Scan����������������������������������������������������������������������������������������������������������������� 248
Exec������������������������������������������������������������������������������������������������������������������������� 255
SQLite���������������������������������������������������������������������������������������������������������������������� 257

Summary����������������������������������������������������������������������������������������������������������263

Chapter 14: CrowdSec����������������������������������������������������������������������265


Source Code������������������������������������������������������������������������������������������������������265
CrowdSec Project����������������������������������������������������������������������������������������������266
Using CrowdSec������������������������������������������������������������������������������������������������������ 266
crowdsec.db������������������������������������������������������������������������������������������������������������ 270

Learning From CrowdSec���������������������������������������������������������������������������������273


System Signal Handling������������������������������������������������������������������������������������������� 274
Handling Service Dependencies������������������������������������������������������������������������������ 280
GeoIP Database������������������������������������������������������������������������������������������������������� 285

Summary����������������������������������������������������������������������������������������������������������290

x
Table of Contents

Part VI: Terminal User Interface���������������������������������������293


Chapter 15: ANSI and UI�������������������������������������������������������������������293
Source Code������������������������������������������������������������������������������������������������������293
ANSI Escape Code���������������������������������������������������������������������������������������������294
ANSI-Based UI���������������������������������������������������������������������������������������������������296
Color Table��������������������������������������������������������������������������������������������������������������� 296
Styling Text�������������������������������������������������������������������������������������������������������������� 299

Open Source Library�����������������������������������������������������������������������������������������300


Gookit���������������������������������������������������������������������������������������������������������������������� 300
Spinner�������������������������������������������������������������������������������������������������������������������� 303

Summary����������������������������������������������������������������������������������������������������������306

Chapter 16: TUI Framework��������������������������������������������������������������307


uiprogress���������������������������������������������������������������������������������������������������������307
Code Flow���������������������������������������������������������������������������������������������������������������� 309
Updating Progress��������������������������������������������������������������������������������������������������� 310

Bubbletea����������������������������������������������������������������������������������������������������������313
Init��������������������������������������������������������������������������������������������������������������������������� 315
Update��������������������������������������������������������������������������������������������������������������������� 318
View������������������������������������������������������������������������������������������������������������������������� 319

Summary����������������������������������������������������������������������������������������������������������321

Part VII: Linux System������������������������������������������������������325


Chapter 17: systemd�������������������������������������������������������������������������325
Source Code������������������������������������������������������������������������������������������������������325
systemd������������������������������������������������������������������������������������������������������������������� 325
systemctl����������������������������������������������������������������������������������������������������������������� 329
Hello Server systemd���������������������������������������������������������������������������������������������� 332

xi
Table of Contents

go-systemd Library������������������������������������������������������������������������������������������������� 334


Summary����������������������������������������������������������������������������������������������������������������� 345

Chapter 18: cadvisor������������������������������������������������������������������������347


Source Code������������������������������������������������������������������������������������������������������347
Running cAdvisor����������������������������������������������������������������������������������������������347
Web User Interface��������������������������������������������������������������������������������������������352
Architecture������������������������������������������������������������������������������������������������������355
Initialization�������������������������������������������������������������������������������������������������������357
Manager������������������������������������������������������������������������������������������������������������361
Monitoring Filesystem��������������������������������������������������������������������������������������368
Information from /sys and /proc�����������������������������������������������������������������������371
Client Library�����������������������������������������������������������������������������������������������������375
Summary����������������������������������������������������������������������������������������������������������375

Index�������������������������������������������������������������������������������������������������377

xii
About the Author
Nanik Tolaram is a big proponent of open source software with over 20
years of industry experience. He has dabbled in different programming
languages like Java, JavaScript, C, and C++. He has developed different
products from the ground up while working in start-up companies. He is
a software engineer at heart, but he loves to write technical articles and
share his knowledge with others. He learned to program with Go during
the COVID-19 pandemic and hasn’t looked back.

xiii
About the Technical Reviewer
Fabio Claudio Ferracchiati is a senior consultant and a senior
analyst/developer using Microsoft technologies. He works for BluArancio
(www.bluarancio.com). He is a Microsoft Certified Solution Developer for
.NET, a Microsoft Certified Application Developer for .NET, a Microsoft
Certified Professional, and a prolific author and technical reviewer.
Over the past ten years, he’s written articles for Italian and international
magazines and coauthored more than ten books on a variety of
computer topics.

xv
Acknowledgments
Thanks to everyone on the Apress team who helped and guided me so
much. Special thanks to James Robinson-Prior who guided me through
the writing process and to Nirmal Selvaraj who made sure everything was
done correctly and things were on track.
Thanks to the technical reviewers for taking time from their busy
schedules to review my book and provide great feedback.
Finally, thanks to you, the reader, for spending time reading this book
and spreading the love of Go.

xvii
Introduction
Go has been out for more than 10 years, and open source projects were
developed using Go. The aim of this book is to show you the way to use Go
to write a variety of applications that are useful in cloud-based systems.
Deploying applications into the cloud is a normal process that
developers do every day. There are many questions that developers ask
themselves about the cloud, like

• How do containers work in a cloud environment?

• How do cloud monitoring applications knows how


much memory is left for my virtual machines?

• How can I build a high performance networking server


in Linux environment?

• How do I scan code before deploying to the cloud


to stop code deployment if it contains related
information?

and many other cloud-relevant questions.


The book talk about different topics that are relevant in today’s cloud
environment. The approach is to explain each topic at a high level and
then help you understand it by going through the details with the code.
The book uses combination of open source projects hosted in GitHub and
sample code. The open source projects chosen are relevant to the topic.
You will get a good grasp about the tool and also how the code works
internally.

xix
CHAPTER 1

System Calls
Linux provides a lot of features and provides applications access to
everything that the operating system has access to. When discussing
system calls, most people will turn their attention to using C because
it is the most common language to use when interfacing with the
operating system.
In this chapter, you will explore what system calls are and how you can
program in Go to make system calls. By the end of this chapter, you will
have learned the following:

• What a system call looks like in C

• Understanding the sys/unix Go package

• Exploring a project using system calls

If you are using Go for the first time, refer to the online documentation
at https://go.dev/doc/install. The online documentation will walk you
through the steps to install Go on your local computer. Go through the Go
tutorial that the Go documentation provides at https://go.dev/doc/.

Source Code
The source code for this chapter is available from the https://github.
com/Apress/Software-Development-Go repository.

© Nanik Tolaram 2023 3


N. Tolaram, Software Development with Go,
https://doi.org/10.1007/978-1-4842-8731-6_1
Chapter 1 System Calls

What Is a System Call?


A system call is the interface provided by the underlying operating system
that your application is currently running on. Using this interface, your
application can communicate with the operating system to perform an
operation. In general, the operating system provides numerous services
that applications can take advantage of.
Figure 1-1 shows at a high level how an application uses system calls
to request some service operation to the operating system. The user
app will make a call to the provided system library, which in this case is
the Go library, and it will call the operating system service through the
provided interface. Data transfer flows in both directions for the different
components.

Figure 1-1. High-level view of a system call

Operating systems provide a large number of system calls that


applications can use. Figure 1-2 shows a snapshot list of system calls. For a
complete available Linux system call list, you can visit ­https://man7.org/
linux/man-pages/man2/syscalls.2.html.

4
Chapter 1 System Calls

Figure 1-2. Snapshot of a Linux system call

C System Call
In this section, you will briefly look at how system calls normally work
inside a C program. This will give you an idea of how system calls are done
in C compared to how they are done in Go.
You will see a simple example of using a socket to connect to a server
and read the response. The code can be found inside the chapter1/c
directory. The code creates a socket and uses it to connect to a public
website named httpbin.org and print the response it receives to the
screen. Listing 1-1 shows the sample code.

Listing 1-1. Sample Code

#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<arpa/inet.h>

5
Chapter 1 System Calls

#include<netdb.h>

int main(int argc, char * argv[]) {


int socket_desc;
struct sockaddr_in server;
char * message, server_reply[2000];
struct hostent * host;
const char * hostname = "httpbin.org";
//Create socket
socket_desc = socket(AF_INET, SOCK_STREAM, 0);
if (socket_desc == -1) {
   printf("Could not create socket");
}

if ((server.sin_addr.s_addr = inet_addr(hostname)) ==


0xffffffff) {
   if ((host = gethostbyname(hostname)) == NULL) {
     return -1;
   }

   memcpy( & server.sin_addr, host -> h_addr, host ->


h_length);
}

server.sin_family = AF_INET;
server.sin_port = htons(80);

if (connect(socket_desc, (struct sockaddr * ) & server,


sizeof(server)) < 0) {
   puts("connect error");
   return 1;
}
puts("Connected\n");
//Send some data

6
Chapter 1 System Calls

message = "GET / HTTP/1.0\n\n";


if (send(socket_desc, message, strlen(message), 0) < 0) {
   puts("Send failed");
   return 1;
}
puts("Data Send\n");
//Receive a reply from the server
if (recv(socket_desc, server_reply, 2000, 0) < 0) {
   puts("recv failed");
}
puts("Reply received\n");
puts(server_reply);
return 0;
}

To test the code, make sure you have a C compiler installed in your
machine. Follow the instructions outlined on the GCC website to install
the compiler and tools (https://gcc.gnu.org/). Use the following
command to compile the code:

cc sample.c -o sample

The code will be compiled to an executable named sample, and it can


be run by just typing ./sample on the command line. After a successful
run, it will print out the following:

Connected

Data Send

Reply received

HTTP/1.1 200 OK

7
Chapter 1 System Calls

Date: Tue, 01 Mar 2022 10:21:13 GMT


Content-Type: text/html; charset=utf-8
Content-Length: 9593
Connection: close
Server: gunicorn/19.9.0
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true

The code sample shows the system call that it uses to resolve the
address of httpbin.org to an IP address by using the gethostbyname
function. It also uses the connect function to use the newly created socket
to connect to the server.
In the next section, you will start exploring Go by using the standard
library to write code using system calls.

sys/unix Package
The sys/unix package is a package provided by the Go language that
provides a system-level interface to interact with the operating system. Go
can run on a variety of operating systems, which means that it provides
different interfaces to applications for different operating systems.
Complete package documentation can be found at https://pkg.go.dev/
golang.org/x/sys/unix. Figure 1-3 shows different system calls in
different operating systems, in this case between Darwin and Linux.

8
Chapter 1 System Calls

Figure 1-3. System calls in Linux vs. Darwin

Listing 1-2 shows how to use system calls using the sys/unix package.

Listing 1-2. Go System Call

package main

import (
  u "golang.org/x/sys/unix"
  "log"
)

func main() {
  c := make([]byte, 512)

  log.Println("Getpid : ", u.Getpid())


  log.Println("Getpgrp : ", u.Getpgrp())
  log.Println("Getppid : ", u.Getppid())
  log.Println("Gettid : ", u.Gettid())

  _, err := u.Getcwd(c)

9
Chapter 1 System Calls

  if err != nil {


     log.Fatalln(err)
  }

  log.Println(string(c))
}

The code prints out information that it obtained by calling the


following system calls:

Getpid Obtains the process id of the current running sample


app
Getpgrp Obtains the group process id of the current running
app
Getppid Obtains the parent process id of the current running
app
Gettid Obtains the caller’s thread it

Running the app on a Linux machine will result in output something


like the following:

2022/02/19 21:25:59 Getpid :  12057


2022/02/19 21:25:59 Getpgrp :  12057
2022/02/19 21:25:59 Getpgrp :  29162
2022/02/19 21:25:59 Gettid :  12057
2022/02/19 21:25:59 /home/nanik/

The other system call that the application uses is to get the current
working directory using the Getcwd function.

System Call in Go
In the previous section, you looked at a simple example of using the sys/
unix package. In this section, you will explore more on system calls by

10
Chapter 1 System Calls

looking at an open source project. The project can be found at https://


github.com/tklauser/statx. This project works similarly to the stat
command in Linux for printing out statistical information about a
particular file.
Change your directory to the statx project and compile and run the
app as follows:

go run statx.go ./README.md

You will see output as follows:

  File: ./README.md
  Size: 476                Blocks: 8        
IO Block: 4096   regular file
Device: fd01h/64769d      Inode: 2637168   
Links:    1
Access: (0644/-rw-r--r--) Uid:    (1000/     nanik)  
Gid: (1000/   nanik)
Access: 2022-02-19 18:10:29.919351223 +1100 AEDT
Modify: 2022-02-19 18:10:29.919351223 +1100 AEDT
Change: 2022-02-19 18:10:29.919351223 +1100 AEDT
Birth: 2022-02-19 18:10:29.919351223 +1100 AEDT
Attrs: 0000000000000000 (-----....)

How does the application get all this information about the file? It
obtains the information from the operating system by making a system
call. Let's take a look at the code in Listing 1-3.

Listing 1-3. Code Using statx

import (
   ....

   "golang.org/x/sys/unix"
)

11
Chapter 1 System Calls

   ....
func main() {
   log.SetFlags(0)
   flag.Parse()

   if len(flag.Args()) < 1 {


       flag.Usage()
       os.Exit(1)
   }
   ....
   for _, arg := range flag.Args() {
       var statx unix.Statx_t
       if err := unix.Statx(unix.AT_FDCWD, arg, flags, mask,
&statx); err != nil {
   ....
       dev := unix.Mkdev(statx.Dev_major, statx.Dev_minor)
   ....
}

As seen in the snippet, the application uses a unix.Statx system


call and it passes filename and other relevant arguments. The system
call is provided as part of the golang.org/x/sys/unix package, which is
declared as follows:

func Statx(dirfd int, path string, flags int, mask int,


stat *Statx_t) (err error)

Declaration and documentation of the Statx function system call can


be found in the following link: https://pkg.go.dev/golang.org/x/sys/
unix. Going through the documentation, there is not much information
about the parameters. As an alternative, you can take a look at the same
system call defined for Linux, which can be found at https://man7.org/
linux/man-pages/man2/statx.2.html. Figure 1-4 shows information about
the different parameters that the function call accepts and what they mean.

12
Chapter 1 System Calls

Figure 1-4. Linux statx

On successful return from calling the unix.Statx function, the


application processes the information that is inside the statx variable
to extract information. The variable is of type Statx_t, which is defined
as follows in the sys/unix package. The struct contains a fair amount of
data pertaining to the file that the application has access to. Using this
information, the application will print out information such as file size,
type of file, user id, and group id.

13
Chapter 1 System Calls

type Statx_t struct {


  Mask            uint32
  Blksize         uint32
  Attributes      uint64
  Nlink           uint32
  Uid             uint32
  Gid             uint32
  Mode            uint16
  _               [1]uint16
  Ino             uint64
  Blocks          uint64
  Attributes_mask uint64
  Atime           StatxTimestamp
  ...
  Dev_major       uint32
  Dev_minor       uint32
  ...
}

Summary
In this chapter, you learned what system calls are and how to write a
simple application to interface with the operating system by using the
sys/unix package. You dug deeper into system calls by looking at an open
source project to learn how it uses the system calls to provide statistical
information about a particular file.
In the next chapters, you will explore system calls more and you will
look at various ways to interface with the operating system using Go.

14
CHAPTER 2

System Calls Using


Go
In this chapter, you will explore writing applications that perform system-­
level operations using system calls. The operating system provides a lot of
ways for applications to extract information and perform operations. You
will look at the different ways to extract system-level information and use
both the Go standard library and system files.
In this chapter, you will learn the following:

• How to use syscall packages

• How to understand and read ELF format files

• How to use the /sys filesystem


• How to write a simple application to read disk statistics

Source Code
The source code for this chapter is available from the https://github.
com/Apress/Software-Development-Go repository.

© Nanik Tolaram 2023 15


N. Tolaram, Software Development with Go,
https://doi.org/10.1007/978-1-4842-8731-6_2
Chapter 2 System Calls Using Go

Syscall Package
The syscall package is the standard library provided by Go that provides
function calls that interface with the log-level operating system. The
following are some of the functionalities provided by the package:
• Change directory

• Duplicate file descriptor

• Get current working directory

• …and many more

syscall Application
Let’s take the existing application from Chapter 1 and convert it to use
the syscall package. The app can be seen inside the chapter2/syscalls
directory. Open terminal and run the sample as follows:

go run main.go

You will see the following output:

2022/07/17 19:20:42 Getpid :  23815


2022/07/17 19:20:42 Getpgrp :  23712
2022/07/17 19:20:42 Getpgrp :  23712
2022/07/17 19:20:42 Gettid :  23815
2022/07/17 19:20:42 /home/nanik/go/chapter2/syscal

The sample code uses system calls to get information about itself such
as the process id assigned by the operating system for itself, the parent id,
and others. The following shows how it uses the syscall package:

package main

import (

16
Chapter 2 System Calls Using Go

  "log"
  s "syscall"
)

func main() {
  ...

  log.Println("Getpid : ", s.Getpid())


  ...

  _, err := s.Getcwd(c)

  ...
}

The code is the same except for replacing the golang.org/x/sys/


unix package with the syscall package, while the function call remains
the same.
Figure 2-1 shows the comparison between the sys/unix and syscall
packages. As you can see, there are functions providing the same
functionality available in both packages.

17
Chapter 2 System Calls Using Go

Figure 2-1. sys/unix vs. syscall

Checking Disk Space


You are going to take a look at an example application that can be found
inside the chapter2/diskspace directory. The application uses the
syscall package to obtain hard disk information such as free space, total
space, and such.
Open terminal and run the sample as follows:

go run main.go

You will see the following output:

Total Disk Space : 460.1 GB


Total Disk Used  : 322.4 GB
Total Disk Free  : 137.7 GB

18
Chapter 2 System Calls Using Go

The output shows in gigabytes the total size of the drive, total amount
of disk used, and total amount of disk free. The following code snippet
shows how the disk information is obtained using the syscall package:

func main() {
  var statfs = syscall.Statfs_t{}
  var total uint64
  var used uint64
  var free uint64
  err := syscall.Statfs("/", &statfs)
  if err != nil {
     fmt.Printf("[ERROR]: %s\n", err)
  } else {
     total = statfs.Blocks * uint64(statfs.Bsize)
     free = statfs.Bfree * uint64(statfs.Bsize)
     used = total - free
  }

  ...
}

As seen in the above code snippet, the application uses the syscall.
Statfs function call to get information about the path. In this case, it’s the
root directory. The result is populated into the statfs variable, which is of
type Statfs_t. The Statfs_t struct declaration looks like the following:

type Statfs_t struct {


  Type    int64
  Bsize   int64
  Blocks  uint64
  Bfree   uint64
  Bavail  uint64
  Files   uint64
  Ffree   uint64

19
Chapter 2 System Calls Using Go

  Fsid    Fsid
  Namelen int64
  Frsize  int64
  Flags   int64
  Spare   [4]int64
}

Webserver with syscall


Let’s take a look at another example using the syscall package, which can
be found inside the chapter2/webserversyscall directory. The sample
code is a web server that uses the syscall package to create a socket
connection.
Open terminal and run the sample as follows:

go run main.go

You will see the following output:

2022/07/17 19:27:49 Listening on  127.0.0.1 : 8888

The web server is now ready to accept connection on port 8888. Open
your browser and type in http://localhost:8888. You will get a response
in your browser: Server with syscall
The following code snippet shows the function that takes care of
starting up the server that listens on port 8888:

func startServer(host string, port int) (int, error) {


  fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_
STREAM, 0)
  if err != nil {
     log.Fatal("error (listen) : ", err)
  }

20
Chapter 2 System Calls Using Go

  sa := &syscall.SockaddrInet4{Port: port}


  addrs, err := net.LookupHost(host)
  ...
  for _, addr := range addrs {
  ...
  }
  ...
  return fd, nil
}

The code performs the following process:


• Creates a socket
• Binds a socket to port 8888
• Listens for an incoming request
The code use syscall.Socket to create a socket. Once it is able to
create a socket, it will bind it to the specified port 8888 by calling syscall.
Bind, as shown in the following code snippet:

for _, addr := range addrs {


  ...
  if err = syscall.Bind(fd, srv); err != nil {
     log.Fatal("error (bind) : ", err)
  }
}

On successful completion of the binding process, the code starts


listening for incoming requests, as shown here:

if err = syscall.Listen(fd, syscall.SOMAXCONN); err != nil {


  log.Fatal("error (listening) : ", err)
} else {
  log.Println("Listening on ", host, ":", port)
}

21
Chapter 2 System Calls Using Go

The syscall.Listen is called, passing syscall.SOMAXCONN as the


parameter. This instructs the operating system that the code wants to have
the maximum queue allocated to take care of pending connections when
they happen. Now the server is ready to accept connections.
The next part of the code accepts and processes incoming requests,
which can be seen in the following code snippet:

for {
  cSock, cAddr, err := syscall.Accept(fd)

  if err != nil {


    ...
  }

  go func(clientSocket int, clientAddress syscall.Sockaddr) {


     err := syscall.Sendmsg(clientSocket, []byte(message),
[]byte{}, clientAddress, 0)
     ...
     syscall.Close(clientSocket)
  }(cSock, cAddr)
}

The code uses syscall.Accept to start accepting incoming requests,


as can be seen in the for{} loop. On every accepted request, the code
processes the request by processing it in a separate go routine. This allows
the server to be able to process incoming requests without being blocked.

ELF Package
The standard library provides different packages that can be used to
interact with different parts of the operating system. In the previous
sections, you looked at interacting on a system level by using the different
standard library packages. In this section, you will look at the debug/elf
package.

22
Chapter 2 System Calls Using Go

This package provides interfaces for applications to interact with


ELF files. ELF stands for the Executable Linkable Format, which means
that an ELF file can be an executable or object file that is used for linking
processes to create an executable file. I will not go into detail on ELF; more
information can be found at https://linux.die.net/man/5/elf.

High-Level ELF Format


ELF is a common standard file format for executable files, object code,
shared libraries, and core dumps; it is cross platform. Figure 2-2 shows at
high level the structure of an ELF file.

Figure 2-2. ELF file structure

23
Chapter 2 System Calls Using Go

Figure 2-3 shows output of the header section of a sample application


compiled on my local machine.

Figure 2-3. ELF file header section

Dump Example
In this section, you will take a look at an open source project named
GoPlay, which is hosted at https://github.com/n4ss/GoPlay. It can also
be found inside the chapter2/GoPlay directory. This is a simple app that
dumps the contents of a Go ELF executable file. You will look at how the
application uses the Go library to read the ELF file
Compile the GoPlay application to create an executable using the
following command:

go build main.go

Now compile GoPlay and run it as follows:

./goplay -action=dump -filename=./goplay

24
Chapter 2 System Calls Using Go

You are instructing GoPlay to dump the contents of the goplay


executable, which will give you output something like the following:

Tracing program : "[path]goplay".


Action : "dump".
DynStrings:
Symbols:
      go.go
      runtime.text
      cmpbody
      countbody
      memeqbody
      indexbody
      indexbytebody
      gogo
      callRet
      gosave_systemstack_switch
      setg_gcc
      aeshashbody
      debugCall32
      debugCall64

      ....
      runtime.(*cpuProfile).addNonGo
      ....
       _cgo_init
       runtime.mainPC
       go.itab.syscall.Errno,error
       runtime.defaultGOROOT.str
       runtime.buildVersion.str
       type.*
       runtime.textsectionmap
   ....

25
Chapter 2 System Calls Using Go

Let’s start analyzing how the code works and what system calls it is
using to get what information out from the executable file.

func main() {
   ....
       file, err := os.Stat(*filename)
   ....
       f, err := os.Open(*filename)
   ....
       switch *action {
   ....
       case "dump": os.Exit(dump_elf(*filename))
       }
   } else {
       goto Usage
   }
   ....
}

On startup, the application uses the os.Stat system call to check


whether the executable file specified as the parameter exists and opens
it using os.Open if it does exist. Once open, it will use the function dump_
elf(..) to dump the file contents. The following is a snippet of the function:

func dump_elf(filename string) int {


   file, err := elf.Open(filename)
   if err != nil {
       fmt.Printf("Couldn't open file : \"%s\" as an ELF.\n")
       return 2
   }
   dump_dynstr(file)
   dump_symbols(file)
   return 0
}

26
Chapter 2 System Calls Using Go

The function uses another system call named elf.Open, which is


available inside the debug/elf package. This is similar to the os.Open
function but with the additional functionality that the opened file is
prepared to be read as an ELF file. On returning from calling elf.Open,
the returned file variable will be populated with information about the
internals of the ELF file.
Once the file is open, it calls dump_symbols to dump the file contents.
The dump_symbols function dumps all symbols information from the file,
which is made available by calling the file.Symbols() function. The
application just prints the Name field.

func dump_symbols(file *elf.File) {


   fmt.Printf("Symbols:\n")
   symbols, _ := file.Symbols()
   for _, e := range symbols {
       if !strings.EqualFold(e.Name, "") {
           fmt.Printf("\t%s\n", e.Name)
       }
   }
}

The following is the struct definition of the Symbol struct. As you can
see, it contains useful information.

type Symbol struct {


  Name        string
  Info, Other byte
  Section     SectionIndex
  Value, Size uint64

27
Chapter 2 System Calls Using Go

  // Version and Library are present only for the


dynamic symbol
  // table.
  Version string
  Library string
}

The other function called to dump ELF information is dump_dynstr:

func dump_dynstr(file *elf.File) {


  fmt.Printf("DynStrings:\n")
  dynstrs, _ := file.DynString(elf.DT_NEEDED)
  ...
  dynstrs, _ = file.DynString(elf.DT_SONAME)
  ...
  dynstrs, _ = file.DynString(elf.DT_RPATH)
  ...
  dynstrs, _ = file.DynString(elf.DT_RUNPATH)
  ...
}

This function is used to obtain certain parts of the ELF file, which are
passed as parameters when calling the file.DynString function. For
example, when calling

dynstrs, _ = file.DynString(elf.DT_SONAME)

the code will get information about the shared library name of the file.

/sys Filesystem
In this section, you will look at a different way of reading system-level information.
You will not use a function to read system information; rather, you will use system
directories that are made available by the operating system for user applications.

28
Chapter 2 System Calls Using Go

The directory that you want to read is the /sys directory, which is a
virtual filesystem containing device drivers, device information, and other
kernel features. Figure 2-4 shows what the /sys directory contains on a
Linux machine.

Figure 2-4. Inside the /sys directory

Reading AppArmor
Some of the information that is provided by Linux inside the /sys
directory is related to AppArmor (short for Application Armor). What is
AppArmor? It is a kernel security module that gives system administrators
the ability to restrict application capabilities with a profile. This gives
system administrators the power to select which resources a particular
application can have access to. For example, a system administrator can
define Application A to have network access or raw socket access, while
Application B does not have access to network capabilities.
Let’s look at an example application to read AppArmor information
from the /sys filesystem, specifically whether AppArmor is enabled and
whether it is enforced. The following is the sample code that can be found
inside the chapter2/apparmor directory:

import (
  "fmt"

29
Chapter 2 System Calls Using Go

   ...
)

const (
  appArmorEnabledPath = "/sys/module/apparmor/parameters/
enabled"
  appArmorModePath    = "/sys/module/apparmor/parameters/mode"
)

func appArmorMode() (mode string) {


  content, err := ioutil.ReadFile(appArmorModePath)
  ...
  return strings.TrimSpace(string(content))
}

func appArmorEnabled() (support bool) {


  content, err := ioutil.ReadFile(appArmorEnabledPath)
  ...
  return strings.TrimSpace(string(content)) == "Y"
}

func main() {
  fmt.Println("AppArmor mode : ", appArmorMode())
  fmt.Println("AppArmor is enabled : ", appArmorEnabled())
}

Since the code is accessing a system filesystem, you must run it using
root. Compile the code and run it as follows:

sudo ./apparmor

The code reads the information from the directory using the standard
library ioUtil.ReadFile, which is just like reading a file, so it’s simpler
than using the function calls that you looked at in the previous sections.

30
Chapter 2 System Calls Using Go

Summary
In this chapter, you looked at using system calls to interface with the
operating system. You looked at using the syscall standard library that
provides a lot of function calls to interface with the operating system
and wrote a sample application to print out disk space information.
You looked at how the debug/elf standard library is used to read Go
ELF file information. Lastly, you looked at the /sys filesystem to extract
information that you want to read to understand whether the operating
system supports AppArmor.

31
Other documents randomly have
different content
— Une purée, sans doute… des cartes de visite qui ne sont pas
gravées… et du temps à perdre comme tous ces pierrots-là qui sont
raides !… avec ça des boniments à la noix… total, une demi-heure
d’emmerdement — et pour la peau… Fais-le entrer tout de même…
on verra bien…
De son cigare il indiqua un siège au visiteur et, selon son
habitude, attendit avant de lui adresser la parole, faisant ainsi
preuve, sans y avoir réfléchi le moins du monde, d’une savante
diplomatie.
L’autre, après avoir cherché du regard un endroit où poser son
chapeau, se décida, en fin de compte, pour ses genoux et se mit à
exposer, d’une voix hésitante, avec des phrases maladroites
surchargées de retouches, le motif de sa visite.
— Le but du Nouveau-Journal, Monsieur le directeur, d’après ce
que j’ai compris et ce que m’ont assuré des personnes autorisées
appartenant pour la plupart — pour une large part, du moins, au
monde de la politique, de la science et des lettres, se proposerait de
ne point suivre les errements… les errements…
Il souffla, à ce mot, tira de sa poche un large mouchoir de coton
rayé et se moucha gauchement :
— Je disais donc que votre journal… votre estimable — et
justement estimé — je le déclare — journal… d’après ce que j’ai
compris, avait à cœur d’éviter les errements…
Fred Matchless consulta sa montre-bracelet :
— Vous en avez pour longtemps ? demanda-t-il.
— Plaît-il ?
Les regards des deux hommes s’affrontèrent. Celui du visiteur
céda misérablement. Il se réfugia sur le revers d’une redingote
élimée où la rosette d’officier d’académie évoquait la proverbiale
modestie de la violette. L’homme eut un long soupir :
— Le reste de la presse, en effet, continua-t-il, se désintéresse
ab-so-lu-ment — il avait détaché de façon pédantesque les syllabes
du mot — d’une des questions les plus angoissantes de l’heure
présente : celle des classes libérales. Ces classes libérales, vous ne
l’ignorez pas, Monsieur…
L’ancien boxeur lui coupa la parole :
— Où voulez-vous en venir ?
Mais l’autre était lancé maintenant. L’index pointé contre un
ennemi imaginaire, il poursuivit :
— Elles n’en peuvent plus, monsieur, les classes libérales. Elles
crèvent littéralement de faim, elles qui sont le sel de la nation…
Fred, en un haussement d’épaules d’infini détachement :
— Que voulez-vous que ça me foute !… Non, mais des fois, vous
imaginez-vous que j’ai du temps à perdre ?… Vous l’imaginez-
vous ?…
Il avançait vers son interlocuteur. L’autre esquissa un mouvement
de prudente retraite :
— Je croyais… j’avais pensé, fit-il… excusez…
Et il détala piteusement, tandis que Fred Matchless, à travers la
porte restée ouverte, interpellait le garçon de bureau :
— Espèce de pochetée ! Face de rat ! Du schnok ! Quand tu verras
s’amener des ballots comme çui-là, si tu ne me les vires pas, et plus
vite que ça, tu verras — ce n’est rien de le dire — comme ton sâle
proze fera connaissance avec mes écrase-miffle !…

— Alors quoi, Fred, il n’y a plus d’amour ! dit Grand-Gosse qui fit
irruption dans la pièce, attiré par le tapage et, refermant
soigneusement la porte sur lui, continua :
— Je suis sûr que tu ne doutes pas qui est chez moi ?… Je te le
donne en mille…
— Si c’est un fourneau comme celui qui sort d’ici…
— Pour un fourneau, je te prie de croire que ce n’est pas un
fourneau, il sait nager… D’ailleurs, tu le connais… Ah ! mon vieux, je
n’en reviens pas…
— C’est bon ! C’est bon ! Va au refil…
— Guillaumet…
— Gui…? Je croyais que…
— Il en est sorti. Oh ! ce n’est pas bien vieux… ce matin, il y a
deux heures à peine. Et il a tenu…
— A ce que tu aies le pucelage. Charmant ! Comment as-tu bien
pu le recevoir ?…
— Il n’a eu garde de se présenter sous son nom… J’aurais pu
hésiter… quoiqu’au fond… Il m’a fait passer une carte ainsi libellée :

Antoine Muller,
Commission-Exportation.

« Muller est le nom de sa femme… Je n’y ai vu que du feu…


— Et il est dans ton bureau ?
— Installé dans le meilleur fauteuil, et pas près d’en décarrer, je
te prie de le croire…
— Eh bien ! c’est du propre !
— Pourquoi ça ?
— Le Nouveau-Journal n’est pas que je sache une succursale du
ballon…
— L’antichambre, tout au plus…
— Tu dis ?
— Rien. Je pense tout haut, simplement… Si tu savais comme il
est rigolo… Il est entré d’autor… sans la moindre gêne… Un rescapé,
a-t-il dit, dès le seuil, à qui vous allez faire, Fred et toi, le grand
honneur — en même temps que le plaisir — de déjeuner avec lui…
Oh ! sans chichi, à la fortune du pot… ou plutôt du dépôt…
— Quel esprit !
— … d’à propos, n’est-ce pas ?
— Il peut se l’agrafer, s’il compte sur moi…
— Tu viendras.
— Je te jure bien que non.
— Ne dis pas des bêtises. Chauvert en est…
— Je les croyais brouillés…
— Laisse-moi tranquille !… Est-ce qu’on se brouille entre
faisans !…
— Chauvert, du moins, n’a pas été dans le trou.
— Que tu dis.
— En tout cas, ça ne s’est pas su.
— Tu m’amuses, ma parole, on te dirait pondu d’hier ! Est-ce qu’à
Paris on se souvient ? Un mois passe sur une photo parue dans un
canard et l’on ne se souvient plus si c’était un cliché
anthropométrique, la frime du prince de Galles ou celle du champion
du dernier match de rugby…
— C’est entendu, mais tu m’avoueras, de toi à moi, que
Guillaumet a été un peu fort. Une autre condamnation et il risque
d’être relégué.
— L’amnistie sera là pour un coup… Il compte même sur toi
pour…
La sonnerie du téléphone les interrompit. Fred Matchless se
pencha sur l’appareil :
— Le Nouveau-Journal, parfaitement… La direction, elle-même…
Ah ! c’est vous, Maublanc, je suis bien content de vous avoir au bout
du fil…
Ayant passé un des récepteurs à Grand-Gosse, il continua :
— … pour une engueulade, vous allez avoir une engueulade. J’ai
envoyé quelqu’un à la Chancellerie… trêve de boniments, il n’y a
aucune objection de ce côté-là… par conséquent, c’est votre patron
qui met des bâtons dans les roues, nous lui revaudrons ça au
prochain tournant. Mais si, mais si, comme je vous le dis !… Quant à
vous, mon petit, vous savez ce que vous savez… donnant, donnant…
C’est comme pour la naturalisation de Goldensohn, cela traîne de
façon un peu trop exagérée. De vous à moi, je peux vous dire que
Goldensohn commence à s’impatienter… Oh ! rien encore… Ne vous
alarmez pas, mais enfin, mettez-vous à sa place… Je sais bien qu’il
peut le faire et je suis le dernier à le plaindre, mais comme il dit
« moi je sème, je sème toujours et la récolte elle ne vient pas du
tout, mein Gott ! »
Ce fut à Grand-Gosse de lui succéder à l’appareil :
— Mon vieux Maublanc, je t’avertis que ça ne va pas du tout pour
ton matricule. J’ai vu le président, à l’issue du Conseil des ministres
hier… tu n’es pas sans ignorer comme il porte ton patron dans son
cœur… ce n’est rien de le dire… la solidarité ministérielle, quoi !… Or,
tu sais aussi bien que moi que les « papiers » de Jules Sorbier dans
l’Éclaireur de Paris passent à juste titre pour être inspirés par lui… et
tu l’as vue la petite note de l’Éclaireur de Paris de ce matin… Nous
avons hésité pour savoir si nous ne la ferions pas figurer dans notre
revue de la presse… Notre chef d’informations l’avait déjà envoyée
au marbre… c’est moi qui l’ai arrêtée… Oh ! tu n’as pas à me
remercier… encore du moins… elle est composée… on peut
reprendre cela avec un commentaire, demain, en guise d’éditorial…
à moins que… (Mademoiselle, ne nous coupez pas…) Quoi ? quoi ? tu
demandes les conditions ? mais on te les a dites : la croix à laquelle
nous avons droit et la naturalisation de Goldensohn… à moins que
vous ne préfériez la guerre. C’est à prendre ou à laisser. Au revoir,
mon vieux, mon bon souvenir à ta ravissante poupée blonde…
Ayant raccroché le récepteur, Grand-Gosse se tourna vers Fred
Matchless et eut un geste gamin :
— Et voilà ! Maublanc doit avoir, à l’heure qu’il est, les foies. Je
crois la partie gagnée. La promotion paraît après-demain. C’est
couru d’avance, dans un fauteuil. Mais ce n’est pas tout ça, je vais
rejoindre cet excellent Guillaumet.
L’ancien boxeur plaisanta lourdement :
— Aurais-tu laissé ta montre sur le bureau ?
— Ma montre ? Est-ce que tu t’imagines qu’il fait le détail ?
Et Grand-Gosse sortit avec une dignité fort bien jouée.
Il n’avait guère changé physiquement depuis certain départ
précipité, bien qu’il eût connu des jours assez rudes à Southampton
d’abord, puis à Londres, où, d’avoir trop bu de gin, après deux jours
d’un jeûne forcé, il avait failli mourir de congestion sur le seuil d’un
saloon. La guerre devait, par la suite, lui paraître une assez médiocre
aventure. Il avait poussé la discrétion jusqu’à y prendre la part
exacte d’héroïsme convenable à un adolescent qui, à force de
tricher, a perdu le goût des cartes.
Fred, quand il songea à créer un journal, après certaines
spéculations audacieuses sur les stocks américains, s’enquit de lui,
utilisa heureusement son savoir et son savoir-faire et lui confia la
rédaction en chef à des appointements tels que, du jour au
lendemain, le jeune compagnon de Grand-Gosse eut son carnet de
chèques, son chemisier et sa manucure. Ses yeux seuls avaient vieilli
à cause sans doute de ces paupières meurtries qu’on eût dit d’un
convalescent. Il ne l’était point cependant, mais de ceux-là plutôt qui
entretiennent amoureusement leur fièvre et s’en nourrissent.
Sa sténo-dactylo, qui lui servait aussi de secrétaire, disait de lui,
à qui voulait bien s’intéresser à ses propos :
— On lui donnerait le bon Dieu sans confession, ce qui vaudrait
mieux, en somme, parce qu’est-ce qu’il vous balancerait comme
confession !
Elle le croyait dangereux, cynique et faible tout à la fois.
En réalité, il cherchait son équilibre et, comme il aimait le risque,
et que, malgré les apparences contraires, il possédait une extrême
élégance morale, c’était au bord du précipice qu’il se livrait à ce jeu.
— Ah ! s’il voulait, pensait cette fluette enfant à la nuque châtaine
et rase, qui tapait sous sa dictée son courrier et ses articles, comme
les femmes — moi la première, pourquoi pas, après tout ? —
seraient à lui corps et âme !
Mais, pour vouloir, il faut le temps, et cet effort d’attention qui
semble tellement profane à de certaines têtes ! Puis Grand-Gosse, il
faut bien l’avouer, malgré son dévergondage verbal, était un
pudique. La femme, avec son appétit sensuel toujours en éveil, lui
faisait peur, et cette éternelle initiative qu’elles escomptent de
vous !… La fermeté d’un regard masculin lui en imposait davantage.
De son éducation en une sombre ville sarrazine sur la frontière de
l’Espagne mystique, il n’avait retenu que la volupté suspecte du
sacrifice. Celle-ci, il faut bien en convenir, n’est point sans inquiéter
quelque peu cette simple gourmandise amoureuse dans laquelle
s’est réfugié le sens pratique de nos contemporaines. Il datait, ou
anticipait — on ne savait au juste — mais son cœur n’était pas à la
page, si son esprit, à force de prétendre y être, exagérait parfois.
XIII

Guillaumet, si le hasard l’avait fait naître à l’époque bénie de la


Renaissance, eût rendu des points aux mécènes les plus fastueux.
Nul ne s’entendait comme lui à recevoir, et ceci soit dit sans jeu de
mots.
Le déjeuner auquel il avait convié, avec Chauvert, le directeur et
le rédacteur en chef du Nouveau-Journal, dans un des salons
particuliers du restaurant le plus justement réputé de la rue Daunou,
pouvait passer pour le fin des fins de l’art culinaire. Une merveilleuse
corbeille de roses rouges et saumon et de dahlias pourpres
garnissait la table. Dès les belons et le pouilly qui les accompagnait,
les langues se délièrent :
— Alors, questionna Chauvert, tu as appris l’anglais et le russe ?
On peut dire que tu sais mettre à profit les loisirs forcés qu’une
justice indiscrète t’assure de temps à autre.
Guillaumet, le monocle assuré dans une figure poupine d’enfant
de chœur, observa :
— Le temps passe vite quand on exerce sa mémoire.
— Combien d’années as-tu tiré, demanda Chauvert, depuis que
tu t’expliques dans la finance ?
— Une douzaine, moins quelques mois…
— Du train où tu vas, tu ne manqueras point, à moins que les
petits cochons ne te mangent en route, de devenir polyglotte.
Fred Matchless paraissait fort peu goûter ces plaisanteries.
Depuis qu’il était devenu un personnage, un grand souci de
respectabilité l’habitait. Il n’avait rien fallu de moins que toute
l’insistance de Grand-Gosse, lui affirmant que Guillaumet avait une
affaire « épatante et de tout repos » à lui proposer et que Chauvert
serait des leurs, pour le décider à prendre part à ces agapes. Il eut à
cœur de faire dévier la conversation :
— Que comptes-tu faire maintenant, Guillaumet ?
— Continuer, dit celui-ci en jouant avec sa fourchette à huîtres…
J’ai une combinaison concernant les gisements de pétrole du Sud-
Ouest dont vous me direz des nouvelles…
— Ça va chercher loin, ces histoires-là. Dans les dix ans, au
moins, énonça impitoyablement Chauvert.
— Trêve de rosserie… Si le Nouveau-Journal m’aide, c’est la
fortune pour nous tous.
— T’aider ! t’aider ! Si tu crois que c’est facile. Brûlé comme tu
l’es, insinua timidement Fred Matchless !
— Brûlé… est-ce qu’on est jamais brûlé à Paname quand on a un
peu d’estomac ? Laisse-moi rire ! Puis les pseudos ne sont pas faits
pour les chiens. Est-ce que tu t’imagines que je figurerai sous mon
blaze ? Pour qui me prends-tu ? Guillaumet est mort — ou en
sommeil — en attendant l’amnistie, c’est Antoine Muller que je
m’appelle, à présent.
— Commission et exportation, précisa Grand-Gosse.
— Voici donc ce que vous allez faire au Nouveau-Journal,
poursuivit Guillaumet. Si la combine vous intéresse, et je vous
préviens qu’il y a gros, très gros à gagner.
— On dit toujours ça, hasarda Fred Matchless.
— Je te le prouverai quand tu le voudras, tu sais que je ne suis
pas un enfant et que je n’ai pas, d’autre part, envie, le moins du
monde, de retomber dans le trou. Mais, auparavant, laisse-moi
achever. Il s’agit d’abord de créer un état d’esprit auprès de vos
lecteurs. Je vois très bien la chose. D’abord une dépêche « de notre
correspondant particulier », avec ce titre Du pétrole dans le Sud-
Ouest. Effectivement, il y en a. Vous envoyez un de vos rédacteurs
— un garçon sûr — faire un grand reportage à l’endroit où la nappe
a été repérée.
— L’enfance de l’art, acquiesça Chauvert.
— Les articles font sensation. D’adroites coupures sont
reproduites par nos confrères de Paris et des départements. Puis, le
silence : on laisse mijoter le plat quelque temps, histoire de lui
donner du liant. C’est alors que tu interviens, toi, Chauvert.
— Je te voyais venir.
— Tu espaces habilement dans ton hebdomadaire les
Indiscrétions parisiennes, quelques échos malveillants où tu mets en
doute la réalité des gisements pétrolifères en question. Tu vas aussi
fort que possible, de façon à attirer l’attention du public, mettant en
cause nommément le député des Basses-Landes, dans la
circonscription duquel se trouve la nappe en question. Il se pique au
jeu et te répond. Nous publions sa lettre et l’affaire est amorcée. Le
reste n’est plus rien : constitution de Société, création d’un budget
de publicité, etc… etc… je m’en charge. Pour la part de chacun, cela
sera à débattre entre nous quand vous voudrez…
— Mais y a-t-il réellement du pétrole ? interrompit Grand-Gosse.
— Tu en doutes ? D’abord on en trouve un peu partout en France,
du pétrole… ensuite, dans cette région plus particulièrement.
On discuta chiffres. Un projet d’exploitation fut esquissé. Bref, on
en était aux liqueurs que l’affaire des pétroles du Sud-Ouest était,
comme l’observait Guillaumet, dans le sac.
Chauvert rayonnait :
— Entre faisans, expliqua-t-il, c’est prodigieux comme on finit par
s’entendre.
— Parle pour toi, bougonna d’un air agressif Fred Matchless.
Chauvert se tapa sur la cuisse :
— Elle est bonne, celle-là ! Comme faisandier, je ne me
connaissais à Paris qu’un maître, c’était toi, et voilà — ce n’est pas
gentil — que tu te dégonfles. Ma parole, tu es mûr pour la croix.
— Il est de la prochaine promotion, observa Grand-Gosse.
— Quand je te le disais !
— Et depuis hier du Syndicat de la Presse parisienne.
— Tout arrive, déclara Chauvert. Tu finiras avec la cravate de
commandeur. Cela te pend au pif comme un sifflet de deux ronds.
Fred Matchless ramena dédaigneusement ses épaules :
— Quand tu auras fini de charrier, fit-il — l’ancien lutteur se
retrouvait en lui. Non, mais des fois ! t’imagines-tu que tu m’auras à
l’influence ?
Mais l’autre :
— Ne t’emballes pas, ma gosse ! Je t’aime comme ça ! C’est bien
ton tour, après tout, de faire tomber un peu de fric. Il y a assez de
cavés qui se sont engraissés jusqu’ici. Mais tu as un tort — permets-
moi de te le dire — c’est d’oublier parfois les poteaux…
— Moi ?
— Oui, toi… Oh ! je sais bien, tu m’as chargé de faire en peinard
la liaison entre le Nouveau-Journal et toutes ces combines à la
manque qui risqueraient de compromettre la ligne politique — que tu
dis — de ton canard. C’est moi qui opère à l’extérieur ; pendant que
tu travailles en maison, je m’explique dehors — histoire de
sauvegarder — que tu dis toujours — car ce que tu jactes bien,
maintenant ! — la surface de ton journal. Mais il t’arrive d’oublier —
oh ! ce n’est pas un reproche que je te fais ! mais, enfin ! — de me
donner mon pied. Le prochain coup — foi de Chauvert ! — nous
fadons ou je te grille… Qu’est-ce que tu as dû toucher, par exemple,
dans l’affaire des Laiteries réunies de la banlieue parisienne ! Moi, j’ai
été tout simplement de la revue, et pourtant qui t’avait porté le
tuyau ?…
Fred Matchless ne daigna pas répondre. Il trouvait son
collaborateur occulte — lui qui tutoyait des ministres et émargeait
largement pour le Nouveau-Journal aux fonds secrets — décidément
compromettant.
— Où t’habilles-tu ? lui demanda Guillaumet pour empêcher la
conversation de prendre un tour dangereux.
— Un coupeur espagnol que j’ai connu autrefois et à qui j’ai prêté
quelque argent pour s’installer. Je lui fournis l’étoffe, une étoffe tout
ce qu’il y a de bath, comme tu vois, et tissée exprès pour moi en
Écosse. Tâte… quel grain !… Tu peux courir avant de trouver la
pareille !…
Et, sans la moindre transition, il parla d’un yacht qu’il venait
d’acheter à un membre du Jockey, d’une villa « de 500 billets, sans
compter l’installation » qu’on était en train de construire pour lui à
Guéthary, « une villa tout en pierres de taille » ; de son château du
Blaisois, « un château historique où il y avait un lit dans lequel avait
couché Louis XIII ou Louis XIV. Il ne se rappelait pas au juste — à
un Louis près… »
Grand-Gosse s’amusait follement :
— Est-il réussi comme nouveau riche, l’est-il ?
Guillaumet, à qui il s’adressait, eut un sourire d’infinie lassitude :
— Tout cela, dit-il, ne vaut pas mon château, à moi, en Périgord
où, pour la pendaison de la crémaillère, j’avais à ma droite le
procureur de la République et à ma gauche le président du Tribunal.
Il y avait trois jours que je sortais de Melun, le collège, comme nous
l’appelons, à cause du voisinage d’un établissement de ce genre. J’y
avais comme intime un des rois du chalumeau qui avait débuté à
Marseille en soulevant les devantures avec ce qu’ils appellent le
« sucre d’orge ». Il était employé à l’imprimerie. Toujours l’utilisation
des compétences ! Moi, je fabriquais des sommiers métalliques, sous
l’œil paterne d’un surveillant huché sur son haut tabouret de bar.
« Grâce à un condé, je sortais tous les soirs faire quelque virée
en compagnie de la fille du gardien-chef, une gosseline ferme et
ambrée comme un brugnon, et à qui il ne fallait pas en promettre.
On a fini par se trisser ensemble. J’ai même fait chauffer un train
spécial — comme je te le dis — pour l’amener à Nice. Il n’y a rien
comme quelques années de taule pour vous donner le goût de la
dépense…
Le maître d’hôtel étant entré, juste à ce moment-là, avec les
cigares, cela jeta un froid…
XIV

Devant la grande glace de sa salle de bains, Nicole était nue.


Elle songeait à Jean qui devait venir dans quelques instants, et
toute cette beauté qu’elle allait lui offrir, elle en repassait
méticuleusement les moindres détails.
Elle flatta du bout des doigts les fraises fermes et bises de ses
seins haut placés et sous la blancheur desquels couraient de
minuscules veines bleues, seins d’adolescente de la veille que gonfle
déjà l’ardeur de la femme. Ses cuisses, longues et un peu grenues,
soutenaient un ventre timidement tendu comme pour une craintive
offrande, et où, sous la lumière tamisée du plafonnier, se doraient de
fins copeaux châtains aux reflets roux. Elle leva ses bras potelés
comme ceux d’un enfant pour comparer la couleur jumelle, un peu
plus sombre à peine, de ses aisselles. Un imperceptible duvet noyait
d’une buée ses mollets nerveux. Ses petits pieds cambrés aux ongles
menus, on eût dit la floraison de ses chevilles patriciennes. Elle se
plut ainsi et, pour mieux savourer ce bien-être de se sentir belle et
désirable, elle éteignit un moment ses yeux noisette sous la prière
silencieuse des longs cils. Ses narines battirent, sa nuque rase parut
se gonfler et, des deux côtés de son front étroit, il y eut, aux
tempes, un frémissement imperceptible.
Il la prendrait tout à l’heure. Il y avait quatre ans qu’ils se
désiraient. Elle eut peur.
C’est à l’hôpital du lycée Carnot, à Dijon, où elle était infirmière,
qu’elle l’avait connu. Il y était soigné pour des troubles nerveux
consécutifs à un commencement de commotion provoquée par
l’éclatement d’un obus.
Il profita de son état pour lui tenir des propos ignobles, ayant un
besoin maladif de lui faire et de se faire du mal. Elle le comprit et
elle qui se gardait jalousement depuis une déplorable aventure de sa
dix-huitième année, connut que si elle se donnait à un homme un
jour, ce serait à lui. Il avait, sans le savoir ni le vouloir, pris le
meilleur moyen pour lui plaire qui était de se rendre odieux à ses
regards.
Un dimanche, étant sorti en ville avec les pires voyous d’un
régiment colonial, il rentra ivre et l’ayant rencontrée dans un couloir
il l’insulta. Elle eût dû le faire punir. Elle ne le fit pas. Le lendemain,
elle alla le trouver dans la bibliothèque. Il y cataloguait les livres. On
l’en avait chargé, comme étant le seul parmi tous ces soldats pour la
plupart illettrés, à pouvoir s’y employer.
— Vous m’avez fait beaucoup de peine hier, dit-elle.
Il ne répondit pas.
Elle hésita un moment, puis :
— Votre mère vous écrit-elle quelquefois ? demanda-t-elle en
rougissant.
Il fit non de la tête.
— Vous êtes brouillés ?…
Il se tut.
— Vous avez fait des bêtises ?
Il eut un geste évasif.
— Monsieur Jean de Borce, quand on porte votre nom…
Alors, il ricana :
— Je n’ai plus qu’un sobriquet. On m’appelle Grand-Gosse à
Paris… J’ai tellement roulé !
Il y eut un long silence entre eux deux. Elle parut se contraindre,
hésita un moment, puis se décidant :
— Oh ! je ne vous ferai pas de morale… Je n’ai pas le droit de
vous en faire… mais… mais je voudrais que vous me promettiez, la
guerre finie…
Il la regarda. Elle était toute blanche. Il voulut jouer de son
trouble :
— Qui est-ce qui vous autorise, lui demanda-t-il sur un ton de
mauvaise humeur, à vous occuper ainsi de moi ? Que vous suis-je ?
Si j’ai gâché ma vie, je n’en dois de compte — vous m’entendez bien
— qu’à moi-même.
— Croyez-vous être le seul à…
Elle n’acheva pas. Un soldat entrait pour demander un livre et
comme elle s’en allait, elle l’entendit qui disait à Grand-Gosse :
— Si des fois tu en avais un un peu cochon, vieille frappe, je te
payerai un litre, et du bon, dimanche prochain…
A seize ans, sa mère morte, son père enfermé dans une maison
de santé à la suite d’excès qui avaient détruit à tout jamais sa
lucidité, elle avait été confiée à une sœur aînée de sa mère, mariée
à Dieppe à un ingénieur des constructions navales.
C’était un homme froid, autoritaire et glabre qui, pour se donner
l’air américain, portait des lunettes à branches d’écaille. Il n’avait pas
d’enfant et se prit pour elle d’une affection paternelle. Ayant fait de
sérieuses études pour une jeune fille, elle le secondait de son mieux
dans sa correspondance et dans ses travaux, durant que sa tante
dirigeait les soins du ménage. Celle-ci ne l’aimait guère, bien qu’elle
l’entourât de prévenances. Elle était de ces personnes aigres,
souffreteuses et confites en dévotion pour qui la jeunesse et la
beauté sont une sorte de provocation. Son mari, qui souffrait de
cette existence renfrognée, vivait le plus possible dans la compagnie
de sa nièce, venue un jour, semblait-il, pour apporter dans sa maison
l’aumône d’un peu de vie.
Des ciels, tour à tour d’étain, d’argent et de vert-de-gris, puis
pommelés et ocre, effilochèrent leurs nuages pesants ou inquiets sur
les promenades de ces deux êtres dont l’un se laissait porter par la
vie, tout à la magnifique insouciance de sa jeunesse, alors que
l’autre, attentif et vigilant, guettait sa proie avec le flair perspicace
d’un chien couchant. Deux ans passèrent. Elle mûrissait avec cet
éclat sombre d’un fruit pour qui la lumière est avare.
Un soir, dans son bureau, il essaya de l’attirer à lui. Elle se
débattit et allait crier quand il lui mit la main sur la bouche.
— Partons, dit-il, je quitterai tout pour toi.
Elle refusa. Un immense dégoût monta en elle pour cet homme
aux yeux perdus, aux lèvres balbutiantes qui haletait, les jambes
tremblantes, la face congestionnée, devant elle.
Le soir même, elle décida de s’enfuir. Pour éviter le scandale, il lui
remit une certaine somme avec laquelle elle gagna Paris où elle allait
rejoindre une amie achevant ses études de licence en Sorbonne.
C’était une féministe farouche qui eut tôt fait de la convertir à ses
idées.
Dans son studio de la rue Huyghens, à deux pas de la Rotonde et
du Dôme, elle recevait maintes garçonnes anglaises, américaines,
scandinaves, avec lesquelles elle s’entretenait à perte de vue des
droits de la femme et de l’infériorité de son partenaire masculin. Des
intrigues se nouaient, dont celui-ci, comme de juste, était exclus.
Leur fadeur devinée révoltèrent Nicole. Un grand besoin
d’indépendance, en même temps que de netteté morale, ne cessait
de solliciter les forces obscures de son âme. Un beau jour, elle prit
congé de son amie et décida de voyager.
Cette virginité de corps, dont elle était d’autant plus jalouse
qu’elle avait couru plus de périls, elle prétendait n’en faire l’abandon
— royal, pensait-elle, avec toute l’ingénuité de son jeune orgueil —
qu’à l’être de son choix.
Un soir, à Monte-Carlo, elle perdit son avant-dernier billet de mille
et rejoignit Paris avec, en elle, toute l’incertitude du lendemain.
Il a fallu toute la poésie de ce charmant François d’Assise qui
savait parler aux oiseaux et aux poissons pour élever la pauvreté au
rang d’une grande dame. Les meilleurs chrétiens de nos jours
évitent soigneusement de se commettre avec elle. Affaire de goût,
sans doute. Elle est tellement voyante !
Dans ce petit café où elle était entrée pour, en mangeant un
sandwich, faire l’économie d’un repas, les yeux de Nicole tombèrent
sur les annonces d’un illustré galant.
La veille, on lui avait réclamé sa note à l’hôtel et la blanchisseuse
devait venir le lendemain. Il lui restait 35 francs et quelques sous
devant elle. Elle avait engagé, la semaine précédente, au Crédit
municipal, les rares bijoux qui lui restaient. Sa fierté assaillie de
toutes parts, elle connut, à cette heure, qu’elle penchait en elle
comme un arbre sous la bourrasque…
Le taxi la déposa devant une maison d’excellente apparence
bourgeoise de la rue La Rochefoucauld. Au quatrième étage, elle
sonna. Madame Florence de Bligny, une aimable quinquagénaire,
vint lui ouvrir elle-même, sa bonne, prévint-elle, étant en courses :
— C’est dans le Fou-Rire que vous avez lu mon annonce ? Un très
bon journal et lu par une clientèle très chic — la clientèle étrangère
surtout. Donnez-vous la peine d’entrer. Là, dans le salon japonais,
nous serons mieux pour causer… C’est 100 francs d’inscription… Le
prix n’est pas élevé, comme vous voyez, mais il est suffisant pour
que se produise une sélection parmi les personnes qui viennent faire
appel à mes relations. Je possède — et je peux le dire sans bluffer le
moins du monde — les meilleures de tout Paris. Côté femmes : une
marquise authentique et la femme légitime d’un de nos plus grands
chirurgiens. Elles sont venues me trouver l’une et l’autre pour que je
les mette en rapport avec un jeune homme du monde, bon danseur
de préférence, ayant eu des revers de fortune, mais qui ne soit pas
cependant un coureur d’aventures. J’ai déjà réussi pour l’une d’elle,
ça ne saurait tarder pour l’autre.
« Côté hommes, nous faisons beaucoup avec la politique et la
haute finance, la noblesse aussi — mais moins — elle est si dédorée
en ce moment… Mais je cause, je cause !… Alors, vous étiez venue
pour vous inscrire ?…
Nicole expliqua tout de trac, sans la moindre précaution oratoire,
et la moindre rouerie féminine, son cas. Elle était gênée, très
gênée… elle n’en pouvait plus… et elle n’avait jamais appartenu à
aucun homme…
Un sourire de doute, sitôt apparu que disparu, passa sur les
lèvres carminées de Mme Florence de Bligny, mais devant le regard
de révolte de la visiteuse elle se ravisa subitement :
— Évidemment, évidemment… mais elle ne voulait pas d’ennui…
Vous comprenez… on apprendrait… Toute femme qui n’a pas vingt et
un ans sonnés…
Nicole s’impatientait visiblement. L’entremetteuse, ayant peur de
laisser échapper une occasion aussi rare, se décida enfin…

Cela se passa le soir même dans un entresol voisin. Un gros


homme chauve, bégayant, qui, après lui avoir dit qu’il avait occupé
un des postes les plus importants de l’État, s’affola, voulut se
ressaisir. Elle était devant lui comme une somnambule.
Lorsqu’elle cria de rage et de douleur sous l’abominable blessure,
il prit peur :
— A…lors !… a…lors…! c’é-c’é-tait… vrai !… Moi… je… pensais… je
croy… croyais… On… me… l’a… fait… fait… si… sou…vent !…
Quand elle rentra à son hôtel, une heure après, les nerfs tendus
à en mourir, on lui remit une dépêche. Son oncle et sa tante de
Dieppe avaient été tués la veille dans un accident d’auto. Comme
elle était leur unique héritière, elle devait, à sa majorité, toucher
650.000 francs environ…

Sa vie, à partir de ce moment-là, ne fut plus qu’un repliement.


Elle était aux écoutes d’elle-même, s’auscultant inlassablement pour
essayer de discerner en elle l’être véritable, celui sur lequel n’avait
pu mordre l’écœurante réalité et qu’elle prétendait, malgré qu’elle en
ait, capter à sa source, à seule fin de défier la destinée. Elle était
toute en retrait pour l’élan magnifique d’elle-même, de la Nicole
d’avant, vers l’élu de sa chair et de son esprit.
La guerre vint. Elle se dévoua dans les hôpitaux, sans entrain,
par besoin d’activité et pour se confronter aussi, elle la victime, avec
d’autres victimes…

Elle s’était habillée comme pour sortir, ne voulant pas, par une
sorte de coquetterie inconsciente, avoir l’air de l’attendre.
Dès son entrée et avant que de s’asseoir sur le divan qu’elle lui
indiquait d’un geste, il avait compris son manège :
— Si vous avez une course urgente à faire dit-il, permettez-moi
de vous accompagner, ma voiture est en bas.
Elle rougit :
— Mon ami, dit-elle, je vous attendais, mais j’étais impatiente.
Il la regarda. Elle ne mentait pas.
— Vous êtes gentil, continua-t-elle, d’avoir répondu à mon appel,
car c’est moi qui ai voulu vous voir. Quelle surprise ça été que notre
rencontre à cette répétition générale, depuis le temps… depuis
Dijon…
— Oui.
— Je vous ai reconnu tout d’abord. Vous étiez cependant bien
changé…
— Tant que ça ?
Elle eut un sourire déjà d’esclave heureuse :
— … en mieux.
— Croyez-vous ?
Sa figure s’était rembrunie, il paraissait maintenant sur la
défensive.
— Je suis resté le même, dit-il — le même ou pis, mais la fortune
m’a favorisée.
Elle alla vers une petite table gigogne, arrangea quelques fleurs
dans un vase et revint vers lui :
— Avez-vous pensé quelquefois à moi depuis votre départ de
l’hôpital ?
Il parut réfléchir :
— Et vous ? demanda-t-il.
Elle n’eut qu’un mot :
— Jean !
Et fut près de lui sur le divan.
Il sentit qu’elle s’offrait. Il eut un geste de repli.
— Vous ne me connaissez pas, dit-il.
Ses yeux devenus graves se fixèrent sur les siens :
— Mieux que vous, Jean. Oh ! pensez de moi tout ce que vous
voudrez. Je ne serai pas coquette avec vous… Je vous attends
depuis si longtemps !
Il l’avait pris dans ses bras ; leurs bouches s’unirent et ne se
quittèrent que pour reprendre leur souffle.
— Déshabille-moi, dit-elle en s’étendant sur les coussins.
Il fut à ses genoux et la dévêtit lentement, couvrant son corps de
baisers fiévreux. A son tour, elle arracha ses vêtements,
abandonnant toute pudeur dans le besoin frémissant qu’elle avait de
lui.
L’odeur fauve de leurs deux corps se mélangea pour n’en faire
qu’une où pointait un parfum d’ambre brûlé. Elle s’employa, malgré
le vertige de ses sens, à différer son plaisir pour attendre le sien. Ils
connurent ensemble le bon anéantissement et des minutes
passèrent qui leur semblèrent des heures avant qu’ils ne revinssent
à eux.
Alors il parcourut tout son corps tendu, de baisers savants,
quittant la bouche, pour le creux délicat de l’oreille, s’attardant aux
seins, descendant ensuite vers la région d’ombre chaude dont
l’attirait le secret. Elle gémit, implora puis se livra dans un
ravissement de toute sa chair extasiée.
Puis elle l’attira à elle et osa, avec d’adorables maladresses de
débutante, des caresses analogues. Et, soudain, elle se ressaisit.
Qu’allait-il penser d’elle ?
Mais, maintenant, il l’avait prise dans ses bras. Il la berçait et les
lèvres sur ses cheveux, la dorlotait comme un enfant malade.
Alors, elle eut une confiance absolue, irrésistible en lui. Elle lui
dit, sans en omettre un détail sa vie, sa misérable vie.
Elle sentit, dans un triomphe de tout son être, que ses yeux
fuyants de mauvais sujet se mouillaient de larmes.
— Ma pauvre petite gosse ! dit-il.
Mais elle :
— Jean, mon grand, mon aimé, j’aurais voulu te connaître
avant… avant ce que tu sais… ah ! misère !…
Elle se rhabillait à présent, les yeux fixes, la bouche mauvaise :
— Mais je suis marquée, tu m’entends, mon petit, mon tout petit,
marquée comme une du grand troupeau humain…
Puis le regardant bien en face :
— Toi aussi tu portes le tatouage maudit et c’est pourquoi je t’ai
aimé dès le premier jour. Mais nous nous vengerons, n’est-ce pas ?
Tu le promets, Jean ?
Il la regarda, fut à son veston et alluma une cigarette :
— Tais-toi, dit-il.
Et, à part soi :
— Un peu romantique, peut-être l’enfant, mais de la branche…
XV

Dans cette salle du cercle qu’on appelait le privé et où, devant


chaque ponte, le moindre des jetons, de belles plaques oblongues
couleur jade, était de cinq mille francs, un arménien taillait.
On eût dit d’un automate, tant ses gestes étaient mécaniques. Il
venait de perdre 700.000 francs et, dans ses yeux éteints, on ne
pouvait lire la moindre émotion. Pendant que le croupier payait, il lui
arrivait parfois de sortir une cigarette de son étui en or, de l’allumer,
de la porter à sa bouche avec des gestes réglés sur le même rythme
exactement que celui qu’il avait pour donner les cartes.
Il faisait partie du consortium dont les chances finissaient par
s’équilibrer et qui taillait pour la maison. Celle-ci avait bien changée
depuis qu’elle avait émigré de son ancien local pour s’installer sur les
Boulevards.
Les habitués lui avaient toutefois conservé son ancien nom. Son
propriétaire, Léon, se vantait, non sans raison, de faire
quotidiennement 40.000 francs de cagnotte. Il possédait les casinos
de trois importantes stations balnéaires, avait son écurie de courses
et était devenu un des principaux actionnaires du Nouveau Journal.
Il avait des rabatteurs dans tous les grands palaces, les paquebots et
les trains de luxe. Un ancien général était président du Cercle et il
n’y avait guère de commissaire des jeux qui ne fût décoré. La table
passait pour être une des meilleures de Paris, bien que le déjeuner
n’y coûtât que quinze francs et le dîner un louis. Chaque vendredi il
y avait un dîner de gala où se produisait quelque grande vedette de
théâtre ou de music-hall.
Grand-Père, debout derrière un des pontes assis autour du tapis
vert du privé, notait méticuleusement les points sur un bristol
imprimé divisé en colonnes en tête desquelles se lisait
alternativement les lettres B et P imprimées en rouge. B signifiait le
banquier et P la ponte. Quand le banquier et la ponte avaient le
même point — étaient en cartes, ainsi qu’on s’exprime en langage
de cercle — Grand-Père indiquait d’un trait chevauchant les deux
colonnes cette particularité.
Après avoir trouvé grâce à Grand-Gosse une situation dans les
services de publicité du Nouveau-Journal, il n’avait pas tardé à
revenir à ses premières amours. Le jeu était son élément. Il y vivait
— assez mal d’ailleurs mais y vivait — comme un poisson dans l’eau.
D’opportuns tapages et une surveillance discrète qu’il exerçait dans
ces lieux pour Fred Matchless qui n’était pas fâché d’avoir barre sur
son commanditaire — et aussi pour Chauvert — lui permettaient,
comme il le disait, de se défendre. Il avait, parfois, également,
recours à la bourse de sa fille qui lui avait pardonné, expliquait-il, ses
gamineries, et beaucoup plus rarement — car il y mettait une sorte
de pudeur — à celle de Grand-Gosse.
Comme il était en train de constater sur le carton qu’après une
passe à la ponte, c’était maintenant l’intermittence, une conversation
auprès de lui attira son attention.
— Pensez-vous, disait un gros garçon à la mine réjouie et aux
cheveux frisés, à un petit homme maniéré au monocle circonspect,
pensez-vous que ça fera un pli ! Sir Alexis Vonouzoff veut sa croix de
commandeur. Léon la lui a promise et quand Léon veut quelque
chose…
— Permettez, il y a le ministre des Affaires Étrangères.
— Vous ne savez donc pas que le Nouveau-Journal est devenu le
journal officieux du gouvernement.
— Permettez, permettez… il est inspiré, éclairé si vous le voulez
bien par l’Intérieur.
A ce moment-là, il y eut une discussion entre joueurs et Grand-
Père perdit le fil du récit. Un moment après il perçut ces quelques
mots :
— Mais vous n’ignorez pas la lutte qui va se livrer au sein même
du Ministère, entre l’Intérieur et le nouveau ministre des Affaires
étrangères ?… Sir Alexis Vonouzoff ne veut et ne peut avoir sa croix
que de ce dernier — et il ne l’aura pas… Tant que Morel-Aubier
restera au Quai d’Orsay, il peut en faire son deuil.
— Léon… deux, trois millions… une paille pour lui… quel
placement !… Sir Alexis Vonouzoff… des milliards…

Un moment après au Nouveau-Journal, la sonnerie du téléphone


retentit dans le cabinet du rédacteur en chef. Grand-Gosse qui
attendait une communication de Nicole, se précipita à l’appareil :
— Allo ! qui est là ?… Ah ! c’est vous… Mais oui, je reconnais votre
voix… Du nouveau me dites-vous ? Mon cher Grand-Père vous savez
je suis très, très occupé… Si c’est sérieux, véritablement sérieux,
prenez un taxi et venez… Sans quoi vous savez… Mais oui… un
travail fou…
Ayant raccroché le récepteur, il sonna à un timbre qui se trouvait
à portée de sa main et, quelques secondes après, le secrétaire de la
rédaction entra. C’était un homme aux gestes raides, revêtu d’une
longue blouse bleue, les cheveux coupés à l’ordonnance et qui
portait les moustaches à la gauloise. Il avait à la main une grande
paire de ciseaux comme en ont les tailleurs.
Grand-Gosse s’esclaffa, alors que l’autre paraissait tout
décontenancé :
— Sosthène Grobaleau dans son numéro, annonça avec la voix
d’un chansonnier montmartrois, le rédacteur en chef du Nouveau-
Journal. Est-il réussi ainsi le gaillard ! On ne ferait pas mieux au
Cirque ! Et ce nom à coucher dehors avec deux billets de logement,
Sosthène Grobaleau ! On le dirait inventé ce nom, ma parole…
— Grobaleau est le nom de mon père, répliqua d’un ton
prudhommesque l’interpellé.
— C’est d’autant plus rigolo, mon vieux. Ce serait un
pseudonyme, il n’y aurait plus aucun charme. Dites-donc, posez vos
ciseaux un moment, vous les reprendrez après, et prêtez-moi,
comme dit l’autre, une oreille attentive. Je ne peux pas passer
devant un kiosque à journaux sans y voir de petites brochures
intitulées : Histoires de Pêche, Histoires de Brasserie, Histoires de
tables d’hôtes, Histoires de théâtre, etc… etc…, le tout signé
libéralement Sosthène Grobaleau. Et toutes ces histoires vous les
découpez au petit bonheur, à la queue leu-leu, à droite et à gauche,
va comme je te pousse ! C’est là un petit business qui ne doit pas
vous fatiguer les méninges et si cela vous rapporte quelque argent
ça prouve une fois de plus que le nombre des poires est
incommensurable. Mais dites-donc, mon vieux, il ne faudrait pas
pour cela, négliger votre travail. Je ne vous paye pas pour faire la
concurrence au Père-Coupe-Toujours de la Porte Saint-Denis…
— Monsieur le rédacteur en chef, il me semble que vous ignorez à
qui vous parlez. Je suis membre de la Société des Gens de Lettres,
secrétaire du Syndicat professionnel de la Critique, trésorier du
Groupement de Défense des Romanciers Littéraires…
— Et autres Sociétés Savantes… je sais. Bref, un parfait
fonctionnaire de la République des Lettres. On a même fait, sur
l’amateur de fiches que vous êtes, un mot. On vous appelle la fiche
de consolation. Mais il ne s’agit pas de cela. Fermez d’abord cette
fenêtre qui nous vaut un courant d’air et dites-moi ce que vous
comptez mettre à la une, pour demain, comme cliché ?
— D’abord, cela va de soi, le portrait de Morel-Aubier, le nouveau
ministre des Affaires Étrangères…
— Avec une biographie assez courte — pas de fleurs, surtout, je
vous le recommande.
— Je croyais que sa politique était celle que défendait le journal.
— Comme vous êtes candide, mon cher. Mais il serait trop long
de vous expliquer… Vous l’avez cette photo ?
— Je vais la chercher à la composition.
Au bout d’un moment, Grobaleau revint avec le portrait du
nouvel occupant du Quai d’Orsay, une figure grasse et commune
d’homme chauve avec des bajoues et une barbiche au poil rare.
— Ce qu’il peut être moche dit Grand-Gosse — et quand on
pense qu’on l’a flatté !
— Monsieur Morel-Aubier, prononça solennellement Grobaleau,
me semble avoir l’aspect grave et austère de ces grands bourgeois
qui sont les colonnes de la République.
— Oui, mon vieux… ne te fatigue pas, va ! Et après ça… Ah ! dites
donc, je tiens expressément à ce que passe encore à la une, avec un
titre à cheval, l’article sur le Pétrole dans le Sud-Ouest.
— Je l’aurais vu à la deux. Nous avons la séance de la Chambre,
très importante, la séance du Sénat, puis la manifestation des Pères
de famille, anciens combattants, devant la tombe du Soldat Inconnu.
— Je m’en fous ! Le pétrole, d’abord !
— Mais, monsieur le rédacteur en chef, me permettez-vous de
faire observer que la question ne me semble pas devoir tellement
intéresser le lecteur ?…
— Vous n’y entendez rien.
— De plus, vous ne devez pas être sans ignorer ce qu’on
chuchote un peu partout.
— A savoir ?
Grobaleau commença par bafouiller lamentablement, puis, il dit
tout d’un trait :
— Que c’est là une affaire je ne dirai pas louche — oh certes
non ! — mais suspecte. Que des capitaux allemands et russes…
— Mon vieux, oui ou non vous occupez-vous du secrétariat de la
rédaction ou de la ligne politique du journal ?
— Mais, monsieur, et ma dignité de journaliste, qu’en faites-
vous ?
— Ah ! laissez-moi rigoler avec votre dignité ! Si je n’avais pas
autre chose à faire qu’à vous écouter, je ne vous donnerais pas dix
minutes pour me déclarer la main sur le cœur que vous considérez
la presse comme un sacerdoce et d’autres rengaines aussi éculées…
Vous le portez bien — ce n’est rien de le dire ! — votre nom
Grobaleau. Ah ! fichtre, oui !…
Le garçon de bureau étant entré avec une carte, Grand-Gosse en
prit prétexte pour se débarrasser de son grotesque collaborateur.

Nicole était devant lui, un bouquet de violettes de Parme piqué


dans sa fourrure, la figure toute rosée de l’air du dehors.
— Mon petit, dit-elle, je ne fais qu’entrer et sortir. Je passais
devant le journal, un besoin fou de t’embrasser. N’oublie pas que je
t’attends ce soir à dîner, le plus tôt que tu le pourras…
Elle était contre lui et lui caressait amoureusement les cheveux
quand, jetant distraitement les yeux sur son buvard, elle y vit la
photographie de Morel-Aubier. Ses yeux devinrent hagards, le sang
se retira de ses joues…
— Oh ! fit-elle en portant la main à sa poitrine.
Il la questionna du regard. Elle acquiesça de la tête. Il avait
compris, mais un besoin malsain de la torturer montait en lui :
— Rue Larochefoucauld, c’était ce…
Elle lui entourait le cou de ses bras pour le faire taire :
— Salaud ! dit-il en se dégageant.

Grand-Père s’était assoupi dans l’antichambre en attendant que


Grand-Gosse voulût bien le recevoir. Rien de ce qui lui venait de son
jeune ami n’était capable de le formaliser. Rebuffades, froideur,
moqueries, il acceptait tout, ayant de longtemps pris son parti de
tout supporter et y prenant cette sorte de plaisir béat qu’éprouvent
les dévotes à remâcher des sucreries.
Aussi ne fut-il pas médiocrement surpris quand, à peine introduit
dans le bureau, et ayant en deux mots expliqué les motifs de sa
visite, il vit Grand-Gosse lui tendre cordialement les deux mains :
— Mon vieux Grand-Père, pour une fois, vous pouvez dire que
votre démarche est de celles qui en valent la peine. Je vous prie de
croire que nous n’allons nous ennuyer ni l’un ni l’autre… La fortune
pour nous deux tout simplement… Car vous savez comme je suis
régulier en affaires avec les amis. Mais motus, n’est-ce pas ? Pas un
mot à quiconque ! A Fred, surtout, ni à Chauvert (à ce dernier je me
réserve d’en parler quand il le faudra). Je sais — ici sa figure devint
grave — que Morel-Aubier aime les fruits verts, ça peut l’entraîner
loin cette petite histoire-là — à nous ça peut nous servir. Vous
connaissez bien toujours le petit Masson de la brigade mondaine…
Bon… parfait… Vous allez lui offrir de ma part un billet — vous
m’entendez bien — un billet avec le double à revenir par la suite si je
suis satisfait, à charge pour lui de me procurer le dossier relatif à
Morel-Aubier…
Grand-Père rayonnait — et du contentement de son pupille — et
d’avoir été chargé de ce qu’il considérait comme une mission de
confiance.
Dès lors il eut toutes les audaces :
— Ma fille…
— Eh bien ! votre fille ?…
— Nancy Nangis donne un souper de centième après-demain,
chez elle, et elle serait flattée… honorée… heureuse… que vous lui
fassiez la grâce… la très grande grâce…
— J’ai compris, entendu. J’y serai.
Le vieux n’en pouvait croire ses oreilles.
Il prit les deux mains du jeune homme :
— Merci ! merci ! dit-il d’une voix toute chevrotante d’émotion.
Et il partit, comme un fou, pour annoncer la bonne nouvelle, en
oubliant, du coup, sa canne dans le bureau.
XVI

Dans la salle des Quatre-Colonnes, à la Chambre, un espèce de


nain au poil d’encre, l’index levé vers le plafond, pérorait, au centre
d’un groupe de députés et de journalistes :
— Je vous dis qu’il a du plomb dans l’aile — et je ne parle pas
des intrigues de couloirs.
— Il a une presse excellente, avança quelqu’un.
— Excellente… avez-vous vu certain petit filet dans le dernier
numéro des Indiscrétions Parisiennes ?
— Le canard de Chauvert, une feuille de chantage, ça ne porte
pas.
— Comme si toutes les feuilles, observa avec détachement un
vieil adolescent au sourire désenchanté, ne sont pas plus ou moins
des feuilles de chantage ! Ce que vous appelez chantage dans un
hebdomadaire, s’appelle campagne dans un grand quotidien, mais le
plat est le même, rien que la sauce le plus souvent, de changée. Il y
a, d’un maître-chanteur professionnel à un leader politique, la même
différence qu’entre une rôdeuse des boulevards extérieurs et une
demi-mondaine. D’ailleurs, on a tort de dire du mal du chantage. Il
est à la base de toutes les sociétés. Pas une tractation où il
n’intervienne. Dieu lui-même en a usé avec sa créature et vous
n’ignorez point le rôle que joue, dans l’amour, le chantage
sentimental.
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and


personal growth!

ebooknice.com

You might also like