/mandos/release : revision 13

1

/* -*- coding: utf-8 -*- */

2

/*

3

* Mandos client - get and decrypt data from a Mandos server

1

/* $Id$ */

2

3

/* PLEASE NOTE *

4

* This file demonstrates how to use Avahi's core API, this is

5

* the embeddable mDNS stack for embedded applications.

4

6

*

5

* This program is partly derived from an example program for an Avahi

6

* service browser, downloaded from

7

* <http://avahi.org/browser/examples/core-browse-services.c>. This

8

* includes the following functions: "resolve_callback",

9

* "browse_callback", and parts of "main".

10

*

11

12

* Påhlsson.

13

*

14

* This program is free software: you can redistribute it and/or

15

* modify it under the terms of the GNU General Public License as

16

* published by the Free Software Foundation, either version 3 of the

17

* License, or (at your option) any later version.

18

*

19

* This program is distributed in the hope that it will be useful, but

20

* WITHOUT ANY WARRANTY; without even the implied warranty of

21

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

22

* General Public License for more details.

23

*

24

* You should have received a copy of the GNU General Public License

25

* along with this program. If not, see

26

* <http://www.gnu.org/licenses/>.

27

*

28

* Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and

29

* <https://www.fukt.bsnet.se/~teddy/>.

7

* End user applications should *not* use this API and should use

8

* the D-Bus or C APIs, please see

9

* client-browse-services.c and glib-integration.c

10

*

11

* I repeat, you probably do *not* want to use this example.

30

12

*/

31

13

32

#define _FORTIFY_SOURCE 2

14

/***

15

This file is part of avahi.

16

17

avahi is free software; you can redistribute it and/or modify it

18

under the terms of the GNU Lesser General Public License as

19

published by the Free Software Foundation; either version 2.1 of the

20

License, or (at your option) any later version.

21

22

avahi is distributed in the hope that it will be useful, but WITHOUT

23

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

24

or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General

25

Public License for more details.

26

27

You should have received a copy of the GNU Lesser General Public

28

License along with avahi; if not, write to the Free Software

29

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

30

USA.

31

***/

33

32

34

33

#define _LARGEFILE_SOURCE

35

34

#define _FILE_OFFSET_BITS 64

39

38

#include <stdlib.h>

40

39

#include <time.h>

41

40

#include <net/if.h> /* if_nametoindex */

42

#include <sys/ioctl.h> // ioctl, ifreq, SIOCGIFFLAGS, IFF_UP, SIOCSIFFLAGS

43

#include <net/if.h> // ioctl, ifreq, SIOCGIFFLAGS, IFF_UP, SIOCSIFFLAGS

44

41

45

42

#include <avahi-core/core.h>

46

43

#include <avahi-core/lookup.h>

50

47

#include <avahi-common/error.h>

51

48

52

49

//mandos client part

53

#include <sys/types.h> /* socket(), inet_pton() */

54

#include <sys/socket.h> /* socket(), struct sockaddr_in6,

55

struct in6_addr, inet_pton() */

56

#include <gnutls/gnutls.h> /* All GnuTLS stuff */

57

#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */

50

#include <sys/types.h> /* socket(), setsockopt(), inet_pton() */

51

#include <sys/socket.h> /* socket(), setsockopt(), struct sockaddr_in6, struct in6_addr, inet_pton() */

52

#include <gnutls/gnutls.h> /* ALL GNUTLS STUFF */

53

#include <gnutls/openpgp.h> /* gnutls with openpgp stuff */

58

54

59

55

#include <unistd.h> /* close() */

60

56

#include <netinet/in.h>

67

63

#include <errno.h> /* perror() */

68

64

#include <gpgme.h>

69

65

70

// getopt long

71

#include <getopt.h>

72

66

67

#ifndef CERT_ROOT

68

#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"

69

#endif

70

#define CERTFILE CERT_ROOT "openpgp-client.txt"

71

#define KEYFILE CERT_ROOT "openpgp-client-key.txt"

73

72

#define BUFFER_SIZE 256

74

73

#define DH_BITS 1024

75

74

76

const char *certdir = "/conf/conf.d/cryptkeyreq/";

77

const char *certfile = "openpgp-client.txt";

78

const char *certkey = "openpgp-client-key.txt";

79

80

bool debug = false;

81

82

75

typedef struct {

83

76

gnutls_session_t session;

84

77

gnutls_certificate_credentials_t cred;

86

79

} encrypted_session;

87

80

88

81

89

ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,

90

char **new_packet, const char *homedir){

82

ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){

91

83

gpgme_data_t dh_crypto, dh_plain;

92

84

gpgme_ctx_t ctx;

93

85

gpgme_error_t rc;

94

86

ssize_t ret;

95

ssize_t new_packet_capacity = 0;

96

ssize_t new_packet_length = 0;

87

size_t new_packet_capacity = 0;

88

size_t new_packet_length = 0;

97

89

gpgme_engine_info_t engine_info;

98

90

99

if (debug){

100

fprintf(stderr, "Trying to decrypt OpenPGP packet\n");

101

}

102

103

91

/* Init GPGME */

104

92

gpgme_check_version(NULL);

105

rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);

106

if (rc != GPG_ERR_NO_ERROR){

107

fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",

108

gpgme_strsource(rc), gpgme_strerror(rc));

109

return -1;

110

}

93

gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);

111

94

112

95

/* Set GPGME home directory */

113

96

rc = gpgme_get_engine_info (&engine_info);

153

136

return -1;

154

137

}

155

138

156

/* Decrypt data from the FILE pointer to the plaintext data

157

buffer */

139

/* Decrypt data from the FILE pointer to the plaintext data buffer */

158

140

rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);

159

141

if (rc != GPG_ERR_NO_ERROR){

160

142

fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",

161

143

gpgme_strsource(rc), gpgme_strerror(rc));

162

144

return -1;

163

145

}

164

165

if(debug){

166

fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");

167

}

168

169

if (debug){

170

gpgme_decrypt_result_t result;

171

result = gpgme_op_decrypt_result(ctx);

172

if (result == NULL){

173

fprintf(stderr, "gpgme_op_decrypt_result failed\n");

174

} else {

175

fprintf(stderr, "Unsupported algorithm: %s\n",

176

result->unsupported_algorithm);

177

fprintf(stderr, "Wrong key usage: %d\n",

178

result->wrong_key_usage);

179

if(result->file_name != NULL){

180

fprintf(stderr, "File name: %s\n", result->file_name);

181

}

182

gpgme_recipient_t recipient;

183

recipient = result->recipients;

184

if(recipient){

185

while(recipient != NULL){

186

fprintf(stderr, "Public key algorithm: %s\n",

187

gpgme_pubkey_algo_name(recipient->pubkey_algo));

188

fprintf(stderr, "Key ID: %s\n", recipient->keyid);

189

fprintf(stderr, "Secret key available: %s\n",

190

recipient->status == GPG_ERR_NO_SECKEY

191

? "No" : "Yes");

192

recipient = recipient->next;

193

}

194

}

195

}

196

}

197

146

147

/* gpgme_decrypt_result_t result; */

148

/* result = gpgme_op_decrypt_result(ctx); */

149

/* fprintf(stderr, "Unsupported algorithm: %s\n", result->unsupported_algorithm); */

150

/* fprintf(stderr, "Wrong key usage: %d\n", result->wrong_key_usage); */

151

/* if(result->file_name != NULL){ */

152

/* fprintf(stderr, "File name: %s\n", result->file_name); */

153

/* } */

154

/* gpgme_recipient_t recipient; */

155

/* recipient = result->recipients; */

156

/* if(recipient){ */

157

/* while(recipient != NULL){ */

158

/* fprintf(stderr, "Public key algorithm: %s\n", */

159

/* gpgme_pubkey_algo_name(recipient->pubkey_algo)); */

160

/* fprintf(stderr, "Key ID: %s\n", recipient->keyid); */

161

/* fprintf(stderr, "Secret key available: %s\n", */

162

/* recipient->status == GPG_ERR_NO_SECKEY ? "No" : "Yes"); */

163

/* recipient = recipient->next; */

164

/* } */

165

/* } */

166

198

167

/* Delete the GPGME FILE pointer cryptotext data buffer */

199

168

gpgme_data_release(dh_crypto);

200

169

201

170

/* Seek back to the beginning of the GPGME plaintext data buffer */

202

if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){

203

perror("pgpme_data_seek");

204

}

205

171

gpgme_data_seek(dh_plain, 0, SEEK_SET);

172

206

173

*new_packet = 0;

207

174

while(true){

208

175

if (new_packet_length + BUFFER_SIZE > new_packet_capacity){

209

*new_packet = realloc(*new_packet,

210

(unsigned int)new_packet_capacity

211

+ BUFFER_SIZE);

176

*new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);

212

177

if (*new_packet == NULL){

213

178

perror("realloc");

214

179

return -1;

216

181

new_packet_capacity += BUFFER_SIZE;

217

182

}

218

183

219

ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,

220

BUFFER_SIZE);

184

ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);

221

185

/* Print the data, if any */

222

186

if (ret == 0){

187

/* If password is empty, then a incorrect error will be printed */

223

188

break;

224

189

}

225

190

if(ret < 0){

229

194

new_packet_length += ret;

230

195

}

231

196

232

/* FIXME: check characters before printing to screen so to not print

233

terminal control characters */

234

/* if(debug){ */

235

/* fprintf(stderr, "decrypted password is: "); */

236

/* fwrite(*new_packet, 1, new_packet_length, stderr); */

237

/* fprintf(stderr, "\n"); */

238

/* } */

239

240

/* Delete the GPGME plaintext data buffer */

197

/* Delete the GPGME plaintext data buffer */

241

198

gpgme_data_release(dh_plain);

242

199

return new_packet_length;

243

200

}

249

206

return ret;

250

207

}

251

208

252

void debuggnutls(__attribute__((unused)) int level,

253

const char* string){

209

void debuggnutls(int level, const char* string){

254

210

fprintf(stderr, "%s", string);

255

211

}

256

212

258

214

const char *err;

259

215

int ret;

260

216

261

if(debug){

262

fprintf(stderr, "Initializing GnuTLS\n");

263

}

264

265

217

if ((ret = gnutls_global_init ())

266

218

!= GNUTLS_E_SUCCESS) {

267

219

fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));

268

220

return -1;

269

221

}

270

222

271

if (debug){

272

gnutls_global_set_log_level(11);

273

gnutls_global_set_log_function(debuggnutls);

274

}

275

223

/* Uncomment to enable full debuggin on the gnutls library */

224

/* gnutls_global_set_log_level(11); */

225

/* gnutls_global_set_log_function(debuggnutls); */

226

227

276

228

/* openpgp credentials */

277

229

if ((ret = gnutls_certificate_allocate_credentials (&es->cred))

278

230

!= GNUTLS_E_SUCCESS) {

279

fprintf (stderr, "memory error: %s\n",

280

safer_gnutls_strerror(ret));

231

fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));

281

232

return -1;

282

233

}

283

284

if(debug){

285

fprintf(stderr, "Attempting to use OpenPGP certificate %s"

286

" and keyfile %s as GnuTLS credentials\n", certfile,

287

certkey);

288

}

289

234

290

235

ret = gnutls_certificate_set_openpgp_key_file

291

(es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);

236

(es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);

292

237

if (ret != GNUTLS_E_SUCCESS) {

293

238

fprintf

294

(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"

295

" '%s')\n",

296

ret, certfile, certkey);

239

(stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",

240

ret, CERTFILE, KEYFILE);

297

241

fprintf(stdout, "The Error is: %s\n",

298

242

safer_gnutls_strerror(ret));

299

243

return -1;

300

244

}

301

302

//GnuTLS server initialization

245

246

//Gnutls server initialization

303

247

if ((ret = gnutls_dh_params_init (&es->dh_params))

304

248

!= GNUTLS_E_SUCCESS) {

305

249

fprintf (stderr, "Error in dh parameter initialization: %s\n",

306

250

safer_gnutls_strerror(ret));

307

251

return -1;

308

252

}

309

253

310

254

if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))

311

255

!= GNUTLS_E_SUCCESS) {

312

256

fprintf (stderr, "Error in prime generation: %s\n",

313

257

safer_gnutls_strerror(ret));

314

258

return -1;

315

259

}

316

260

317

261

gnutls_certificate_set_dh_params (es->cred, es->dh_params);

318

319

// GnuTLS session creation

262

263

// Gnutls session creation

320

264

if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))

321

265

!= GNUTLS_E_SUCCESS){

322

fprintf(stderr, "Error in GnuTLS session initialization: %s\n",

266

fprintf(stderr, "Error in gnutls session initialization: %s\n",

323

267

safer_gnutls_strerror(ret));

324

268

}

325

269

326

270

if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))

327

271

!= GNUTLS_E_SUCCESS) {

328

272

fprintf(stderr, "Syntax error at: %s\n", err);

329

fprintf(stderr, "GnuTLS error: %s\n",

273

fprintf(stderr, "Gnutls error: %s\n",

330

274

safer_gnutls_strerror(ret));

331

275

return -1;

332

276

}

333

277

334

278

if ((ret = gnutls_credentials_set

335

279

(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))

336

280

!= GNUTLS_E_SUCCESS) {

338

282

safer_gnutls_strerror(ret));

339

283

return -1;

340

284

}

341

285

342

286

/* ignore client certificate if any. */

343

gnutls_certificate_server_set_request (es->session,

344

GNUTLS_CERT_IGNORE);

287

gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);

345

288

346

289

gnutls_dh_set_prime_bits (es->session, DH_BITS);

347

290

348

291

return 0;

349

292

}

350

293

351

void empty_log(__attribute__((unused)) AvahiLogLevel level,

352

__attribute__((unused)) const char *txt){}

294

void empty_log(AvahiLogLevel level, const char *txt){}

353

295

354

int start_mandos_communication(const char *ip, uint16_t port,

355

unsigned int if_index){

296

int start_mandos_communcation(char *ip, uint16_t port){

356

297

int ret, tcp_sd;

357

298

struct sockaddr_in6 to;

299

struct in6_addr ip_addr;

358

300

encrypted_session es;

359

301

char *buffer = NULL;

360

302

char *decrypted_buffer;

361

303

size_t buffer_length = 0;

362

304

size_t buffer_capacity = 0;

363

305

ssize_t decrypted_buffer_size;

364

size_t written = 0;

365

306

int retval = 0;

366

char interface[IF_NAMESIZE];

367

368

if(debug){

369

fprintf(stderr, "Setting up a tcp connection to %s\n", ip);

370

}

307

371

308

372

309

tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);

373

310

if(tcp_sd < 0) {

374

311

perror("socket");

375

312

return -1;

376

313

}

377

378

if(debug){

379

if(if_indextoname(if_index, interface) == NULL){

380

if(debug){

381

perror("if_indextoname");

382

}

383

return -1;

384

}

385

386

fprintf(stderr, "Binding to interface %s\n", interface);

314

315

ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, "eth0", 5);

316

if(tcp_sd < 0) {

317

perror("setsockopt bindtodevice");

318

return -1;

387

319

}

388

320

389

memset(&to,0,sizeof(to)); /* Spurious warning */

321

memset(&to,0,sizeof(to));

390

322

to.sin6_family = AF_INET6;

391

ret = inet_pton(AF_INET6, ip, &to.sin6_addr);

323

ret = inet_pton(AF_INET6, ip, &ip_addr);

392

324

if (ret < 0 ){

393

325

perror("inet_pton");

394

326

return -1;

397

329

fprintf(stderr, "Bad address: %s\n", ip);

398

330

return -1;

399

331

}

400

to.sin6_port = htons(port); /* Spurious warning */

401

402

to.sin6_scope_id = (uint32_t)if_index;

403

404

if(debug){

405

fprintf(stderr, "Connection to: %s\n", ip);

406

}

332

to.sin6_port = htons(port);

333

to.sin6_scope_id = if_nametoindex("eth0");

407

334

408

335

ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));

409

336

if (ret < 0){

416

343

retval = -1;

417

344

return -1;

418

345

}

419

420

gnutls_transport_set_ptr (es.session,

421

(gnutls_transport_ptr_t) tcp_sd);

422

423

if(debug){

424

fprintf(stderr, "Establishing TLS session with %s\n", ip);

425

}

426

346

347

348

gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);

349

427

350

ret = gnutls_handshake (es.session);

428

351

429

352

if (ret != GNUTLS_E_SUCCESS){

430

if(debug){

431

fprintf(stderr, "\n*** Handshake failed ***\n");

432

gnutls_perror (ret);

433

}

353

fprintf(stderr, "\n*** Handshake failed ***\n");

354

gnutls_perror (ret);

434

355

retval = -1;

435

356

goto exit;

436

357

}

437

438

//Retrieve OpenPGP packet that contains the wanted password

439

440

if(debug){

441

fprintf(stderr, "Retrieving pgp encrypted password from %s\n",

442

ip);

443

}

444

358

359

//retrive password

445

360

while(true){

446

361

if (buffer_length + BUFFER_SIZE > buffer_capacity){

447

362

buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);

472

387

}

473

388

break;

474

389

default:

475

fprintf(stderr, "Unknown error while reading data from"

476

" encrypted session with mandos server\n");

390

fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");

477

391

retval = -1;

478

392

gnutls_bye (es.session, GNUTLS_SHUT_RDWR);

479

393

goto exit;

480

394

}

481

395

} else {

482

buffer_length += (size_t) ret;

396

buffer_length += ret;

483

397

}

484

398

}

485

399

486

400

if (buffer_length > 0){

487

decrypted_buffer_size = pgp_packet_decrypt(buffer,

488

buffer_length,

489

&decrypted_buffer,

490

certdir);

491

if (decrypted_buffer_size >= 0){

492

while(written < (size_t)decrypted_buffer_size){

493

ret = (int)fwrite (decrypted_buffer + written, 1,

494

(size_t)decrypted_buffer_size - written,

495

stdout);

496

if(ret == 0 and ferror(stdout)){

497

if(debug){

498

fprintf(stderr, "Error writing encrypted data: %s\n",

499

strerror(errno));

500

}

501

retval = -1;

502

break;

503

}

504

written += (size_t)ret;

505

}

401

if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) == 0){

402

retval = -1;

403

} else {

404

fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);

506

405

free(decrypted_buffer);

507

} else {

508

retval = -1;

509

406

}

510

407

}

511

408

409

free(buffer);

410

512

411

//shutdown procedure

513

514

if(debug){

515

fprintf(stderr, "Closing TLS session\n");

516

}

517

518

free(buffer);

519

412

gnutls_bye (es.session, GNUTLS_SHUT_RDWR);

520

413

exit:

521

414

close(tcp_sd);

530

423

531

424

static void resolve_callback(

532

425

AvahiSServiceResolver *r,

533

AvahiIfIndex interface,

426

AVAHI_GCC_UNUSED AvahiIfIndex interface,

534

427

AVAHI_GCC_UNUSED AvahiProtocol protocol,

535

428

AvahiResolverEvent event,

536

429

const char *name,

539

432

const char *host_name,

540

433

const AvahiAddress *address,

541

434

uint16_t port,

542

AVAHI_GCC_UNUSED AvahiStringList *txt,

543

AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,

435

AvahiStringList *txt,

436

AvahiLookupResultFlags flags,

544

437

AVAHI_GCC_UNUSED void* userdata) {

545

438

546

assert(r); /* Spurious warning */

547

548

/* Called whenever a service has been resolved successfully or

549

timed out */

550

551

switch (event) {

552

default:

553

case AVAHI_RESOLVER_FAILURE:

554

fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"

555

" type '%s' in domain '%s': %s\n", name, type, domain,

556

avahi_strerror(avahi_server_errno(server)));

557

break;

558

559

case AVAHI_RESOLVER_FOUND:

560

{

561

char ip[AVAHI_ADDRESS_STR_MAX];

562

avahi_address_snprint(ip, sizeof(ip), address);

563

if(debug){

564

fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"

565

" port %d\n", name, host_name, ip, port);

566

}

567

int ret = start_mandos_communication(ip, port,

568

(unsigned int) interface);

569

if (ret == 0){

570

exit(EXIT_SUCCESS);

571

}

439

assert(r);

440

441

/* Called whenever a service has been resolved successfully or timed out */

442

443

switch (event) {

444

case AVAHI_RESOLVER_FAILURE:

445

fprintf(stderr, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_server_errno(server)));

446

break;

447

448

case AVAHI_RESOLVER_FOUND: {

449

char ip[AVAHI_ADDRESS_STR_MAX];

450

avahi_address_snprint(ip, sizeof(ip), address);

451

int ret = start_mandos_communcation(ip, port);

452

if (ret == 0){

453

exit(EXIT_SUCCESS);

454

} else {

455

exit(EXIT_FAILURE);

456

}

457

}

572

458

}

573

}

574

avahi_s_service_resolver_free(r);

459

avahi_s_service_resolver_free(r);

575

460

}

576

461

577

462

static void browse_callback(

586

471

void* userdata) {

587

472

588

473

AvahiServer *s = userdata;

589

assert(b); /* Spurious warning */

590

591

/* Called whenever a new services becomes available on the LAN or

592

is removed from the LAN */

593

474

assert(b);

475

476

/* Called whenever a new services becomes available on the LAN or is removed from the LAN */

477

594

478

switch (event) {

595

default:

596

case AVAHI_BROWSER_FAILURE:

597

598

fprintf(stderr, "(Browser) %s\n",

599

avahi_strerror(avahi_server_errno(server)));

600

avahi_simple_poll_quit(simple_poll);

601

return;

602

603

case AVAHI_BROWSER_NEW:

604

/* We ignore the returned resolver object. In the callback

605

function we free it. If the server is terminated before

606

the callback function is called the server will free

607

the resolver for us. */

608

609

if (!(avahi_s_service_resolver_new(s, interface, protocol, name,

610

type, domain,

611

AVAHI_PROTO_INET6, 0,

612

resolve_callback, s)))

613

fprintf(stderr, "Failed to resolve service '%s': %s\n", name,

614

avahi_strerror(avahi_server_errno(s)));

615

break;

616

617

case AVAHI_BROWSER_REMOVE:

618

break;

619

620

case AVAHI_BROWSER_ALL_FOR_NOW:

621

case AVAHI_BROWSER_CACHE_EXHAUSTED:

622

break;

479

480

case AVAHI_BROWSER_FAILURE:

481

482

fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));

483

avahi_simple_poll_quit(simple_poll);

484

return;

485

486

case AVAHI_BROWSER_NEW:

487

/* We ignore the returned resolver object. In the callback

488

function we free it. If the server is terminated before

489

the callback function is called the server will free

490

the resolver for us. */

491

492

if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))

493

fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));

494

495

break;

496

497

case AVAHI_BROWSER_REMOVE:

498

break;

499

500

case AVAHI_BROWSER_ALL_FOR_NOW:

501

case AVAHI_BROWSER_CACHE_EXHAUSTED:

502

break;

623

503

}

624

504

}

625

505

626

/* combinds file name and path and returns the malloced new string. som sane checks could/should be added */

627

const char *combinepath(const char *first, const char *second){

628

char *tmp;

629

tmp = malloc(strlen(first) + strlen(second) + 2);

630

if (tmp == NULL){

631

perror("malloc");

632

return NULL;

633

}

634

strcpy(tmp, first);

635

if (first[0] != '\0' and first[strlen(first) - 1] != '/'){

636

strcat(tmp, "/");

637

}

638

strcat(tmp, second);

639

return tmp;

640

}

641

642

643

506

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

644

507

AvahiServerConfig config;

645

508

AvahiSServiceBrowser *sb = NULL;

646

509

int error;

647

int ret;

648

int returncode = EXIT_SUCCESS;

649

const char *interface = "eth0";

650

struct ifreq network;

651

int sd;

652

653

while (true){

654

static struct option long_options[] = {

655

{"debug", no_argument, (int *)&debug, 1},

656

{"interface", required_argument, 0, 'i'},

657

{"certdir", required_argument, 0, 'd'},

658

{"certkey", required_argument, 0, 'c'},

659

{"certfile", required_argument, 0, 'k'},

660

{0, 0, 0, 0} };

661

662

int option_index = 0;

663

ret = getopt_long (argc, argv, "i:", long_options,

664

&option_index);

665

666

if (ret == -1){

667

break;

668

}

669

670

switch(ret){

671

case 0:

672

break;

673

case 'i':

674

interface = optarg;

675

break;

676

case 'd':

677

certdir = optarg;

678

break;

679

case 'c':

680

certfile = optarg;

681

break;

682

case 'k':

683

certkey = optarg;

684

break;

685

default:

686

exit(EXIT_FAILURE);

687

}

688

}

689

690

certfile = combinepath(certdir, certfile);

691

if (certfile == NULL){

692

returncode = EXIT_FAILURE;

693

goto exit;

694

}

695

696

certkey = combinepath(certdir, certkey);

697

if (certkey == NULL){

698

returncode = EXIT_FAILURE;

699

goto exit;

700

}

701

702

sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);

703

if(sd < 0) {

704

perror("socket");

705

returncode = EXIT_FAILURE;

706

goto exit;

707

}

708

strcpy(network.ifr_name, interface);

709

ret = ioctl(sd, SIOCGIFFLAGS, &network);

710

if(ret == -1){

711

712

perror("ioctl SIOCGIFFLAGS");

713

returncode = EXIT_FAILURE;

714

goto exit;

715

}

716

if((network.ifr_flags & IFF_UP) == 0){

717

network.ifr_flags |= IFF_UP;

718

ret = ioctl(sd, SIOCSIFFLAGS, &network);

719

if(ret == -1){

720

perror("ioctl SIOCSIFFLAGS");

721

returncode = EXIT_FAILURE;

722

goto exit;

723

}

724

}

725

close(sd);

726

727

if (not debug){

728

avahi_set_log_function(empty_log);

729

}

510

int ret = 1;

511

512

avahi_set_log_function(empty_log);

730

513

731

514

/* Initialize the psuedo-RNG */

732

srand((unsigned int) time(NULL));

515

srand(time(NULL));

733

516

734

517

/* Allocate main loop object */

735

518

if (!(simple_poll = avahi_simple_poll_new())) {

736

519

fprintf(stderr, "Failed to create simple poll object.\n");

737

returncode = EXIT_FAILURE;

738

goto exit;

520

goto fail;

739

521

}

740

522

741

523

/* Do not publish any local records */

745

527

config.publish_workstation = 0;

746

528

config.publish_domain = 0;

747

529

530

/* /\* Set a unicast DNS server for wide area DNS-SD *\/ */

531

/* avahi_address_parse("193.11.177.11", AVAHI_PROTO_UNSPEC, &config.wide_area_servers[0]); */

532

/* config.n_wide_area_servers = 1; */

533

/* config.enable_wide_area = 1; */

534

748

535

/* Allocate a new server */

749

server = avahi_server_new(avahi_simple_poll_get(simple_poll),

750

&config, NULL, NULL, &error);

536

server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);

751

537

752

538

/* Free the configuration data */

753

539

avahi_server_config_free(&config);

754

540

755

/* Check if creating the server object succeeded */

541

/* Check wether creating the server object succeeded */

756

542

if (!server) {

757

fprintf(stderr, "Failed to create server: %s\n",

758

avahi_strerror(error));

759

returncode = EXIT_FAILURE;

760

goto exit;

543

fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));

544

goto fail;

761

545

}

762

546

763

547

/* Create the service browser */

764

sb = avahi_s_service_browser_new(server,

765

(AvahiIfIndex)

766

if_nametoindex(interface),

767

AVAHI_PROTO_INET6,

768

"_mandos._tcp", NULL, 0,

769

browse_callback, server);

770

if (!sb) {

771

fprintf(stderr, "Failed to create service browser: %s\n",

772

avahi_strerror(avahi_server_errno(server)));

773

returncode = EXIT_FAILURE;

774

goto exit;

548

if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {

549

fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));

550

goto fail;

775

551

}

776

552

777

553

/* Run the main loop */

778

779

if (debug){

780

fprintf(stderr, "Starting avahi loop search\n");

781

}

782

783

554

avahi_simple_poll_loop(simple_poll);

784

555

785

exit:

786

787

if (debug){

788

fprintf(stderr, "%s exiting\n", argv[0]);

789

}

556

ret = 0;

557

558

fail:

790

559

791

560

/* Cleanup things */

792

561

if (sb)

797

566

798

567

if (simple_poll)

799

568

avahi_simple_poll_free(simple_poll);

800

free(certfile);

801

free(certkey);

802

803

return returncode;

569

570

return ret;

804

571

}