~jsvoboda/helenos/initbin : revision 696

41

#include <ctype.h>

42

#include <ddi.h>

43

#include <errno.h>

44

#include <err.h>

45

44

#include <malloc.h>

46

45

#include <stdio.h>

47

46

#include <str.h>

91

90

int add_configuration(measured_strings_ref configuration, const char *name,

92

91

const char *value)

93

92

{

94

ERROR_DECLARE;

93

int rc;

95

94

96

95

measured_string_ref setting =

97

96

measured_string_create_bulk(value, 0);

99

98

return ENOMEM;

100

99

101

100

/* Add the configuration setting */

102

if (ERROR_OCCURRED(measured_strings_add(configuration, name, 0, setting))) {

101

rc = measured_strings_add(configuration, name, 0, setting);

102

if (rc != EOK) {

103

free(setting);

104

return ERROR_CODE;

104

return rc;

105

}

106

107

return EOK;

109

110

/** Generate new system-unique device identifier.

111

*

112

* @returns The system-unique devic identifier.

113

*

112

* @returns The system-unique devic identifier.

114

113

*/

115

114

static device_id_t generate_new_device_id(void)

116

115

{

119

118

120

119

static int parse_line(measured_strings_ref configuration, char *line)

121

120

{

122

ERROR_DECLARE;

121

int rc;

123

122

124

123

/* From the beginning */

125

124

char *name = line;

169

168

return ENOMEM;

170

169

171

170

/* Add the configuration setting */

172

if (ERROR_OCCURRED(measured_strings_add(configuration, name, 0, setting))) {

171

rc = measured_strings_add(configuration, name, 0, setting);

172

if (rc != EOK) {

173

free(setting);

174

return ERROR_CODE;

174

return rc;

175

}

176

177

return EOK;

180

static int read_configuration_file(const char *directory, const char *filename,

181

measured_strings_ref configuration)

182

{

183

ERROR_DECLARE;

184

185

183

printf("%s: Reading configuration file %s/%s\n", NAME, directory, filename);

186

184

187

185

/* Construct the full filename */

205

203

if ((read > 0) && (read != '\n') && (read != '\r')) {

206

204

if (index >= BUFFER_SIZE) {

207

205

line[BUFFER_SIZE - 1] = '\0';

208

fprintf(stderr, "%s: Configuration line %u too long: %s\n",

209

NAME, line_number, line);

206

fprintf(stderr, "%s: Configuration line %u too "

207

"long: %s\n", NAME, line_number, line);

210

208

211

209

/* No space left in the line buffer */

212

210

return EOVERFLOW;

213

} else {

214

/* Append the character */

215

line[index] = (char) read;

216

index++;

217

211

}

212

/* Append the character */

213

line[index] = (char) read;

214

index++;

218

215

} else {

219

216

/* On error or new line */

220

217

line[index] = '\0';

221

218

line_number++;

222

if (ERROR_OCCURRED(parse_line(configuration, line)))

223

fprintf(stderr, "%s: Configuration error on line %u: %s\n",

224

NAME, line_number, line);

219

if (parse_line(configuration, line) != EOK) {

220

fprintf(stderr, "%s: Configuration error on "

221

"line %u: %s\n", NAME, line_number, line);

222

}

225

223

226

224

index = 0;

227

225

}

269

267

*/

270

268

static int net_initialize(async_client_conn_t client_connection)

271

269

{

272

ERROR_DECLARE;

270

int rc;

273

271

274

272

netifs_initialize(&net_globals.netifs);

275

273

char_map_initialize(&net_globals.netif_names);

277

275

measured_strings_initialize(&net_globals.configuration);

278

276

279

277

// TODO: dynamic configuration

280

ERROR_PROPAGATE(read_configuration());

278

rc = read_configuration();

279

if (rc != EOK)

280

return rc;

281

282

ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,

283

LO_NAME, LO_FILENAME, SERVICE_LO, 0, connect_to_service));

284

ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,

285

DP8390_NAME, DP8390_FILENAME, SERVICE_DP8390, 0, connect_to_service));

286

ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,

287

ETHERNET_NAME, ETHERNET_FILENAME, SERVICE_ETHERNET, 0,

288

connect_to_service));

289

ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,

290

NILDUMMY_NAME, NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0,

291

connect_to_service));

282

rc = add_module(NULL, &net_globals.modules, LO_NAME, LO_FILENAME,

283

SERVICE_LO, 0, connect_to_service);

284

if (rc != EOK)

285

return rc;

286

rc = add_module(NULL, &net_globals.modules, DP8390_NAME,

287

DP8390_FILENAME, SERVICE_DP8390, 0, connect_to_service);

288

if (rc != EOK)

289

return rc;

290

rc = add_module(NULL, &net_globals.modules, ETHERNET_NAME,

291

ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);

292

if (rc != EOK)

293

return rc;

294

rc = add_module(NULL, &net_globals.modules, NILDUMMY_NAME,

295

NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);

296

if (rc != EOK)

297

return rc;

292

298

293

299

/* Build specific initialization */

294

300

return net_initialize_build(client_connection);

313

319

*/

314

320

static int net_module_start(async_client_conn_t client_connection)

315

321

{

316

ERROR_DECLARE;

322

ipcarg_t phonehash;

323

int rc;

317

324

318

325

async_set_client_connection(client_connection);

319

ERROR_PROPAGATE(pm_init());

320

321

ipcarg_t phonehash;

322

323

if (ERROR_OCCURRED(net_initialize(client_connection)) ||

324

ERROR_OCCURRED(REGISTER_ME(SERVICE_NETWORKING, &phonehash))) {

325

pm_destroy();

326

return ERROR_CODE;

327

}

326

rc = pm_init();

327

if (rc != EOK)

328

return rc;

329

330

331

rc = net_initialize(client_connection);

332

if (rc != EOK)

333

goto out;

334

335

rc = REGISTER_ME(SERVICE_NETWORKING, &phonehash);

336

if (rc != EOK)

337

goto out;

328

338

329

339

async_manager();

330

340

341

out:

331

342

pm_destroy();

332

return EOK;

343

return rc;

333

344

}

334

345

335

346

/** Return the configured values.

414

425

*/

415

426

static int start_device(netif_t *netif)

416

427

{

417

ERROR_DECLARE;

428

int rc;

418

429

419

430

/* Mandatory netif */

420

431

measured_string_ref setting =

455

466

setting = measured_strings_find(&netif->configuration, CONF_IO, 0);

456

467

int io = setting ? strtol(setting->value, NULL, 16) : 0;

457

468

458

ERROR_PROPAGATE(netif_probe_req_remote(netif->driver->phone, netif->id, irq, io));

469

rc = netif_probe_req_remote(netif->driver->phone, netif->id, irq, io);

470

if (rc != EOK)

471

return rc;

459

472

460

473

/* Network interface layer startup */

461

474

services_t internet_service;

467

480

468

481

int mtu = setting ? strtol(setting->value, NULL, 10) : 0;

469

482

470

ERROR_PROPAGATE(nil_device_req(netif->nil->phone, netif->id, mtu,

471

netif->driver->service));

483

rc = nil_device_req(netif->nil->phone, netif->id, mtu,

484

netif->driver->service);

485

if (rc != EOK)

486

return rc;

472

487

473

488

internet_service = netif->nil->service;

474

489

} else

477

492

/* Inter-network layer startup */

478

493

switch (netif->il->service) {

479

494

case SERVICE_IP:

480

ERROR_PROPAGATE(ip_device_req(netif->il->phone, netif->id,

481

internet_service));

495

rc = ip_device_req(netif->il->phone, netif->id,

496

internet_service);

497

if (rc != EOK)

498

return rc;

482

499

break;

483

500

default:

484

501

return ENOENT;

485

502

}

486

503

487

ERROR_PROPAGATE(netif_start_req_remote(netif->driver->phone, netif->id));

488

return EOK;

504

return netif_start_req_remote(netif->driver->phone, netif->id);

489

505

}

490

506

491

507

/** Read the configuration and start all network interfaces.

503

519

*/

504

520

static int startup(void)

505

521

{

506

ERROR_DECLARE;

507

508

522

const char *conf_files[] = {

509

523

"lo",

510

524

"ne2k"

511

525

};

512

526

size_t count = sizeof(conf_files) / sizeof(char *);

527

int rc;

513

528

514

529

size_t i;

515

530

for (i = 0; i < count; i++) {

521

536

if (!netif->id)

522

537

return EXDEV;

523

538

524

ERROR_PROPAGATE(measured_strings_initialize(&netif->configuration));

539

rc = measured_strings_initialize(&netif->configuration);

540

if (rc != EOK)

541

return rc;

525

542

526

543

/* Read configuration files */

527

if (ERROR_OCCURRED(read_netif_configuration(conf_files[i], netif))) {

544

rc = read_netif_configuration(conf_files[i], netif);

545

if (rc != EOK) {

528

546

measured_strings_destroy(&netif->configuration);

529

547

free(netif);

530

return ERROR_CODE;

548

return rc;

531

549

}

532

550

533

551

/* Mandatory name */

553

571

* Add to the netif names map and start network interfaces

554

572

* and needed modules.

555

573

*/

556

if ((ERROR_OCCURRED(char_map_add(&net_globals.netif_names,

557

netif->name, 0, index))) || (ERROR_OCCURRED(start_device(netif)))) {

558

measured_strings_destroy(&netif->configuration);

559

netifs_exclude_index(&net_globals.netifs, index);

560

return ERROR_CODE;

574

rc = char_map_add(&net_globals.netif_names, netif->name, 0,

575

index);

576

if (rc != EOK) {

577

measured_strings_destroy(&netif->configuration);

578

netifs_exclude_index(&net_globals.netifs, index);

579

return rc;

580

}

581

582

rc = start_device(netif);

583

if (rc != EOK) {

584

measured_strings_destroy(&netif->configuration);

585

netifs_exclude_index(&net_globals.netifs, index);

586

return rc;

561

587

}

562

588

563

589

/* Increment modules' usage */

593

619

int net_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,

594

620

int *answer_count)

595

621

{

596

ERROR_DECLARE;

597

598

622

measured_string_ref strings;

599

623

char *data;

624

int rc;

600

625

601

626

*answer_count = 0;

602

627

switch (IPC_GET_METHOD(*call)) {

603

628

case IPC_M_PHONE_HUNGUP:

604

629

return EOK;

605

630

case NET_NET_GET_DEVICE_CONF:

606

ERROR_PROPAGATE(measured_strings_receive(&strings, &data,

607

IPC_GET_COUNT(call)));

631

rc = measured_strings_receive(&strings, &data,

632

IPC_GET_COUNT(call));

633

if (rc != EOK)

634

return rc;

608

635

net_get_device_conf_req(0, IPC_GET_DEVICE(call), &strings,

609

636

IPC_GET_COUNT(call), NULL);

610

637

611

638

/* Strings should not contain received data anymore */

612

639

free(data);

613

640

614

ERROR_CODE = measured_strings_reply(strings, IPC_GET_COUNT(call));

641

rc = measured_strings_reply(strings, IPC_GET_COUNT(call));

615

642

free(strings);

616

return ERROR_CODE;

643

return rc;

617

644

case NET_NET_GET_CONF:

618

ERROR_PROPAGATE(measured_strings_receive(&strings, &data,

619

IPC_GET_COUNT(call)));

645

rc = measured_strings_receive(&strings, &data,

646

IPC_GET_COUNT(call));

647

if (rc != EOK)

648

return rc;

620

649

net_get_conf_req(0, &strings, IPC_GET_COUNT(call), NULL);

621

650

622

651

/* Strings should not contain received data anymore */

623

652

free(data);

624

653

625

ERROR_CODE = measured_strings_reply(strings, IPC_GET_COUNT(call));

654

rc = measured_strings_reply(strings, IPC_GET_COUNT(call));

626

655

free(strings);

627

return ERROR_CODE;

656

return rc;

628

657

case NET_NET_STARTUP:

629

658

return startup();

630

659

}

660

631

661

return ENOTSUP;

632

662

}

633

663

669

699

670

700

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

671

701

{

672

ERROR_DECLARE;

702

int rc;

673

703

674

if (ERROR_OCCURRED(net_module_start(net_client_connection))) {

675

fprintf(stderr, "%s: net_module_start error %i\n", NAME, ERROR_CODE);

676

return ERROR_CODE;

704

rc = net_module_start(net_client_connection);

705

if (rc != EOK) {

706

fprintf(stderr, "%s: net_module_start error %i\n", NAME, rc);

707

return rc;

677

708

}

678

709

679

710

return EOK;