/mandos/trunk : revision 670

183

perror(print_text);

184

}

185

186

__attribute__((format (gnu_printf, 2, 3), nonnull))

186

__attribute__((format (gnu_printf, 2, 3)))

187

int fprintf_plus(FILE *stream, const char *format, ...){

188

va_list ap;

189

va_start (ap, format);

198

* bytes. "buffer_capacity" is how much is currently allocated,

199

* "buffer_length" is how much is already used.

200

*/

201

__attribute__((nonnull, warn_unused_result))

202

201

size_t incbuffer(char **buffer, size_t buffer_length,

203

202

size_t buffer_capacity){

204

203

if(buffer_length + BUFFER_SIZE > buffer_capacity){

217

216

}

218

217

219

218

/* Add server to set of servers to retry periodically */

220

__attribute__((nonnull, warn_unused_result))

221

219

bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,

222

220

int af, server **current_server){

223

221

int ret;

244

242

new_server->next = new_server;

245

243

new_server->prev = new_server;

246

244

*current_server = new_server;

245

/* Place the new server last in the list */

247

246

} else {

248

/* Place the new server last in the list */

249

247

new_server->next = *current_server;

250

248

new_server->prev = (*current_server)->prev;

251

249

new_server->prev->next = new_server;

257

255

/*

258

256

* Initialize GPGME.

259

257

*/

260

__attribute__((nonnull, warn_unused_result))

261

258

static bool init_gpgme(const char *seckey, const char *pubkey,

262

259

const char *tempdir, mandos_context *mc){

263

260

gpgme_error_t rc;

353

350

* Decrypt OpenPGP data.

354

351

* Returns -1 on error

355

352

*/

356

__attribute__((nonnull, warn_unused_result))

357

353

static ssize_t pgp_packet_decrypt(const char *cryptotext,

358

354

size_t crypto_size,

359

355

char **plaintext,

479

475

return plaintext_length;

480

476

}

481

477

482

__attribute__((warn_unused_result))

483

static const char *safer_gnutls_strerror(int value){

478

static const char * safer_gnutls_strerror(int value){

484

479

const char *ret = gnutls_strerror(value);

485

480

if(ret == NULL)

486

481

ret = "(unknown)";

488

483

}

489

484

490

485

/* GnuTLS log function callback */

491

__attribute__((nonnull))

492

486

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

493

487

const char* string){

494

488

fprintf_plus(stderr, "GnuTLS: %s", string);

495

489

}

496

490

497

__attribute__((nonnull, warn_unused_result))

498

491

static int init_gnutls_global(const char *pubkeyfilename,

499

492

const char *seckeyfilename,

500

493

mandos_context *mc){

574

567

return -1;

575

568

}

576

569

577

__attribute__((nonnull, warn_unused_result))

578

570

static int init_gnutls_session(gnutls_session_t *session,

579

571

mandos_context *mc){

580

572

int ret;

637

629

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

638

630

639

631

/* Called when a Mandos server is found */

640

__attribute__((nonnull, warn_unused_result))

641

632

static int start_mandos_communication(const char *ip, in_port_t port,

642

633

AvahiIfIndex if_index,

643

634

int af, mandos_context *mc){

749

740

goto mandos_end;

750

741

}

751

742

if(af == AF_INET6){

752

((struct sockaddr_in6 *)&to)->sin6_port = htons(port);

743

((struct sockaddr_in6 *)&to)->sin6_port = htons(port);

753

744

if(IN6_IS_ADDR_LINKLOCAL

754

745

(&((struct sockaddr_in6 *)&to)->sin6_addr)){

755

746

if(if_index == AVAHI_IF_UNSPEC){

818

809

sizeof(struct sockaddr_in));

819

810

}

820

811

if(ret < 0){

821

if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){

812

if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){

822

813

int e = errno;

823

814

perror_plus("connect");

824

815

errno = e;

1039

1030

return retval;

1040

1031

}

1041

1032

1042

__attribute__((nonnull))

1043

1033

static void resolve_callback(AvahiSServiceResolver *r,

1044

1034

AvahiIfIndex interface,

1045

1035

AvahiProtocol proto,

1053

1043

AVAHI_GCC_UNUSED AvahiStringList *txt,

1054

1044

AVAHI_GCC_UNUSED AvahiLookupResultFlags

1055

1045

flags,

1056

void *mc){

1046

void* mc){

1057

1047

if(r == NULL){

1058

1048

return;

1059

1049

}

1112

1102

const char *domain,

1113

1103

AVAHI_GCC_UNUSED AvahiLookupResultFlags

1114

1104

flags,

1115

void *mc){

1105

void* mc){

1116

1106

if(b == NULL){

1117

1107

return;

1118

1108

}

1178

1168

errno = old_errno;

1179

1169

}

1180

1170

1181

__attribute__((nonnull, warn_unused_result))

1182

1171

bool get_flags(const char *ifname, struct ifreq *ifr){

1183

1172

int ret;

1184

1173

error_t ret_errno;

1203

1192

return true;

1204

1193

}

1205

1194

1206

__attribute__((nonnull, warn_unused_result))

1207

1195

bool good_flags(const char *ifname, const struct ifreq *ifr){

1208

1196

1209

1197

/* Reject the loopback device */

1251

1239

* corresponds to an acceptable network device.

1252

1240

* (This function is passed to scandir(3) as a filter function.)

1253

1241

*/

1254

__attribute__((nonnull, warn_unused_result))

1255

1242

int good_interface(const struct dirent *if_entry){

1256

1243

if(if_entry->d_name[0] == '.'){

1257

1244

return 0;

1275

1262

/*

1276

1263

* This function determines if a network interface is up.

1277

1264

*/

1278

__attribute__((nonnull, warn_unused_result))

1279

1265

bool interface_is_up(const char *interface){

1280

1266

struct ifreq ifr;

1281

1267

if(not get_flags(interface, &ifr)){

1292

1278

/*

1293

1279

* This function determines if a network interface is running

1294

1280

*/

1295

__attribute__((nonnull, warn_unused_result))

1296

1281

bool interface_is_running(const char *interface){

1297

1282

struct ifreq ifr;

1298

1283

if(not get_flags(interface, &ifr)){

1306

1291

return (bool)(ifr.ifr_flags & IFF_RUNNING);

1307

1292

}

1308

1293

1309

__attribute__((nonnull, pure, warn_unused_result))

1310

1294

int notdotentries(const struct dirent *direntry){

1311

1295

/* Skip "." and ".." */

1312

1296

if(direntry->d_name[0] == '.'

1319

1303

}

1320

1304

1321

1305

/* Is this directory entry a runnable program? */

1322

__attribute__((nonnull, warn_unused_result))

1323

1306

int runnable_hook(const struct dirent *direntry){

1324

1307

int ret;

1325

1308

size_t sret;

1380

1363

return 1;

1381

1364

}

1382

1365

1383

__attribute__((nonnull, warn_unused_result))

1384

1366

int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,

1385

1367

mandos_context *mc){

1386

1368

int ret;

1390

1372

1391

1373

while(true){

1392

1374

if(mc->current_server == NULL){

1393

if(debug){

1375

if (debug){

1394

1376

fprintf_plus(stderr, "Wait until first server is found."

1395

1377

" No timeout!\n");

1396

1378

}

1397

1379

ret = avahi_simple_poll_iterate(s, -1);

1398

1380

} else {

1399

if(debug){

1381

if (debug){

1400

1382

fprintf_plus(stderr, "Check current_server if we should run"

1401

1383

" it, or wait\n");

1402

1384

}

1419

1401

- ((intmax_t)waited_time.tv_sec * 1000))

1420

1402

- ((intmax_t)waited_time.tv_nsec / 1000000));

1421

1403

1422

if(debug){

1404

if (debug){

1423

1405

fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",

1424

1406

block_time);

1425

1407

}

1447

1429

ret = avahi_simple_poll_iterate(s, (int)block_time);

1448

1430

}

1449

1431

if(ret != 0){

1450

if(ret > 0 or errno != EINTR){

1432

if (ret > 0 or errno != EINTR){

1451

1433

return (ret != 1) ? ret : 0;

1452

1434

}

1453

1435

}

1455

1437

}

1456

1438

1457

1439

/* Set effective uid to 0, return errno */

1458

__attribute__((warn_unused_result))

1459

1440

error_t raise_privileges(void){

1460

1441

error_t old_errno = errno;

1461

1442

error_t ret_errno = 0;

1468

1449

}

1469

1450

1470

1451

/* Set effective and real user ID to 0. Return errno. */

1471

__attribute__((warn_unused_result))

1472

1452

error_t raise_privileges_permanently(void){

1473

1453

error_t old_errno = errno;

1474

1454

error_t ret_errno = raise_privileges();

1485

1465

}

1486

1466

1487

1467

/* Set effective user ID to unprivileged saved user ID */

1488

__attribute__((warn_unused_result))

1489

1468

error_t lower_privileges(void){

1490

1469

error_t old_errno = errno;

1491

1470

error_t ret_errno = 0;

1498

1477

}

1499

1478

1500

1479

/* Lower privileges permanently */

1501

__attribute__((warn_unused_result))

1502

1480

error_t lower_privileges_permanently(void){

1503

1481

error_t old_errno = errno;

1504

1482

error_t ret_errno = 0;

1510

1488

return ret_errno;

1511

1489

}

1512

1490

1513

__attribute__((nonnull))

1514

void run_network_hooks(const char *mode, const char *interface,

1491

bool run_network_hooks(const char *mode, const char *interface,

1515

1492

const float delay){

1516

1493

struct dirent **direntries;

1517

1494

int numhooks = scandir(hookdir, &direntries, runnable_hook,

1545

1522

if(hook_pid == 0){

1546

1523

/* Child */

1547

1524

/* Raise privileges */

1548

if(raise_privileges_permanently() != 0){

1549

perror_plus("Failed to raise privileges");

1550

_exit(EX_NOPERM);

1551

}

1525

raise_privileges_permanently();

1552

1526

/* Set group */

1553

1527

errno = 0;

1554

1528

ret = setgid(0);

1555

1529

if(ret == -1){

1556

1530

perror_plus("setgid");

1557

_exit(EX_NOPERM);

1558

1531

}

1559

1532

/* Reset supplementary groups */

1560

1533

errno = 0;

1561

1534

ret = setgroups(0, NULL);

1562

1535

if(ret == -1){

1563

1536

perror_plus("setgroups");

1564

_exit(EX_NOPERM);

1565

}

1566

ret = dup2(devnull, STDIN_FILENO);

1567

if(ret == -1){

1568

perror_plus("dup2(devnull, STDIN_FILENO)");

1569

_exit(EX_OSERR);

1570

}

1571

ret = close(devnull);

1572

if(ret == -1){

1573

perror_plus("close");

1574

_exit(EX_OSERR);

1575

}

1576

ret = dup2(STDERR_FILENO, STDOUT_FILENO);

1577

if(ret == -1){

1578

perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");

1579

_exit(EX_OSERR);

1580

}

1537

}

1538

dup2(devnull, STDIN_FILENO);

1539

close(devnull);

1540

dup2(STDERR_FILENO, STDOUT_FILENO);

1581

1541

ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);

1582

1542

if(ret == -1){

1583

1543

perror_plus("setenv");

1599

1559

_exit(EX_OSERR);

1600

1560

}

1601

1561

char *delaystring;

1602

ret = asprintf(&delaystring, "%f", (double)delay);

1562

ret = asprintf(&delaystring, "%f", delay);

1603

1563

if(ret == -1){

1604

1564

perror_plus("asprintf");

1605

1565

_exit(EX_OSERR);

1658

1618

}

1659

1619

close(devnull);

1660

1620

}

1621

return true;

1661

1622

}

1662

1623

1663

__attribute__((nonnull, warn_unused_result))

1664

1624

error_t bring_up_interface(const char *const interface,

1665

1625

const float delay){

1626

int sd = -1;

1666

1627

error_t old_errno = errno;

1667

int ret;

1628

error_t ret_errno = 0;

1629

int ret, ret_setflags;

1668

1630

struct ifreq network;

1669

1631

unsigned int if_index = if_nametoindex(interface);

1670

1632

if(if_index == 0){

1679

1641

}

1680

1642

1681

1643

if(not interface_is_up(interface)){

1682

error_t ret_errno = 0, ioctl_errno = 0;

1683

if(not get_flags(interface, &network)){

1644

if(not get_flags(interface, &network) and debug){

1684

1645

ret_errno = errno;

1685

1646

fprintf_plus(stderr, "Failed to get flags for interface "

1686

1647

"\"%s\"\n", interface);

1687

errno = old_errno;

1688

1648

return ret_errno;

1689

1649

}

1690

network.ifr_flags |= IFF_UP; /* set flag */

1650

network.ifr_flags |= IFF_UP;

1691

1651

1692

int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);

1693

if(sd == -1){

1652

sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);

1653

if(sd < 0){

1694

1654

ret_errno = errno;

1695

1655

perror_plus("socket");

1696

1656

errno = old_errno;

1697

1657

return ret_errno;

1698

1658

}

1699

1659

1700

1660

if(quit_now){

1701

ret = (int)TEMP_FAILURE_RETRY(close(sd));

1702

if(ret == -1){

1703

perror_plus("close");

1704

}

1661

close(sd);

1705

1662

errno = old_errno;

1706

1663

return EINTR;

1707

1664

}

1711

1668

interface);

1712

1669

}

1713

1670

1714

/* Raise privileges */

1715

ret_errno = raise_privileges();

1716

bool restore_loglevel = false;

1717

if(ret_errno != 0){

1718

perror_plus("Failed to raise privileges");

1719

}

1671

/* Raise priviliges */

1672

raise_privileges();

1673

1720

1674

#ifdef __linux__

1721

int ret_linux;

1722

if(ret_errno == 0){

1723

/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO

1724

messages about the network interface to mess up the prompt */

1725

ret_linux = klogctl(8, NULL, 5);

1726

if(ret_linux == -1){

1727

perror_plus("klogctl");

1728

} else {

1729

restore_loglevel = true;

1730

}

1675

/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO

1676

messages about the network interface to mess up the prompt */

1677

int ret_linux = klogctl(8, NULL, 5);

1678

bool restore_loglevel = true;

1679

if(ret_linux == -1){

1680

restore_loglevel = false;

1681

perror_plus("klogctl");

1731

1682

}

1732

1683

#endif /* __linux__ */

1733

int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);

1734

ioctl_errno = errno;

1684

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

1685

ret_errno = errno;

1735

1686

#ifdef __linux__

1736

1687

if(restore_loglevel){

1737

1688

ret_linux = klogctl(7, NULL, 0);

1741

1692

}

1742

1693

#endif /* __linux__ */

1743

1694

1744

/* If raise_privileges() succeeded above */

1745

if(ret_errno == 0){

1746

/* Lower privileges */

1747

ret_errno = lower_privileges();

1748

if(ret_errno != 0){

1749

errno = ret_errno;

1750

perror_plus("Failed to lower privileges");

1751

}

1752

}

1695

/* Lower privileges */

1696

lower_privileges();

1753

1697

1754

1698

/* Close the socket */

1755

1699

ret = (int)TEMP_FAILURE_RETRY(close(sd));

1758

1702

}

1759

1703

1760

1704

if(ret_setflags == -1){

1761

errno = ioctl_errno;

1705

errno = ret_errno;

1762

1706

perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");

1763

1707

errno = old_errno;

1764

return ioctl_errno;

1708

return ret_errno;

1765

1709

}

1766

1710

} else if(debug){

1767

1711

fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",

1785

1729

return 0;

1786

1730

}

1787

1731

1788

__attribute__((nonnull, warn_unused_result))

1789

1732

error_t take_down_interface(const char *const interface){

1790

1733

error_t old_errno = errno;

1791

1734

struct ifreq network;

1796

1739

return ENXIO;

1797

1740

}

1798

1741

if(interface_is_up(interface)){

1799

error_t ret_errno = 0, ioctl_errno = 0;

1742

error_t ret_errno = 0;

1800

1743

if(not get_flags(interface, &network) and debug){

1801

1744

ret_errno = errno;

1802

1745

fprintf_plus(stderr, "Failed to get flags for interface "

1803

1746

"\"%s\"\n", interface);

1804

errno = old_errno;

1805

1747

return ret_errno;

1806

1748

}

1807

1749

network.ifr_flags &= ~(short)IFF_UP; /* clear flag */

1808

1750

1809

1751

int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);

1810

if(sd == -1){

1752

if(sd < 0){

1811

1753

ret_errno = errno;

1812

1754

perror_plus("socket");

1813

1755

errno = old_errno;

1819

1761

interface);

1820

1762

}

1821

1763

1822

/* Raise privileges */

1823

ret_errno = raise_privileges();

1824

if(ret_errno != 0){

1825

perror_plus("Failed to raise privileges");

1826

}

1764

/* Raise priviliges */

1765

raise_privileges();

1766

1827

1767

int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);

1828

ioctl_errno = errno;

1768

ret_errno = errno;

1829

1769

1830

/* If raise_privileges() succeeded above */

1831

if(ret_errno == 0){

1832

/* Lower privileges */

1833

ret_errno = lower_privileges();

1834

if(ret_errno != 0){

1835

errno = ret_errno;

1836

perror_plus("Failed to lower privileges");

1837

}

1838

}

1770

/* Lower privileges */

1771

lower_privileges();

1839

1772

1840

1773

/* Close the socket */

1841

1774

int ret = (int)TEMP_FAILURE_RETRY(close(sd));

1844

1777

}

1845

1778

1846

1779

if(ret_setflags == -1){

1847

errno = ioctl_errno;

1780

errno = ret_errno;

1848

1781

perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");

1849

1782

errno = old_errno;

1850

return ioctl_errno;

1783

return ret_errno;

1851

1784

}

1852

1785

} else if(debug){

1853

1786

fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",

1861

1794

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

1862

1795

mandos_context mc = { .server = NULL, .dh_bits = 1024,

1863

1796

.priority = "SECURE256:!CTYPE-X.509:"

1864

"+CTYPE-OPENPGP", .current_server = NULL,

1797

"+CTYPE-OPENPGP", .current_server = NULL,

1865

1798

.interfaces = NULL, .interfaces_size = 0 };

1866

1799

AvahiSServiceBrowser *sb = NULL;

1867

1800

error_t ret_errno;

2060

1993

/* Work around Debian bug #633582:

2061

1994

<http://bugs.debian.org/633582> */

2062

1995

2063

/* Re-raise privileges */

2064

ret_errno = raise_privileges();

2065

if(ret_errno != 0){

2066

errno = ret_errno;

2067

perror_plus("Failed to raise privileges");

2068

} else {

1996

/* Re-raise priviliges */

1997

if(raise_privileges() == 0){

2069

1998

struct stat st;

2070

1999

2071

2000

if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){

2111

2040

}

2112

2041

2113

2042

/* Lower privileges */

2114

ret_errno = lower_privileges();

2115

if(ret_errno != 0){

2116

errno = ret_errno;

2117

perror_plus("Failed to lower privileges");

2118

}

2043

lower_privileges();

2119

2044

}

2120

2045

}

2121

2046

2147

2072

memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);

2148

2073

argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');

2149

2074

}

2150

run_network_hooks("start", interfaces_hooks != NULL ?

2151

interfaces_hooks : "", delay);

2075

if(not run_network_hooks("start", interfaces_hooks != NULL ?

2076

interfaces_hooks : "", delay)){

2077

goto end;

2078

}

2152

2079

}

2153

2080

2154

2081

if(not debug){

2282

2209

break;

2283

2210

}

2284

2211

bool interface_was_up = interface_is_up(interface);

2285

errno = bring_up_interface(interface, delay);

2212

ret = bring_up_interface(interface, delay);

2286

2213

if(not interface_was_up){

2287

if(errno != 0){

2214

if(ret != 0){

2215

errno = ret;

2288

2216

perror_plus("Failed to bring up interface");

2289

2217

} else {

2290

errno = argz_add(&interfaces_to_take_down,

2291

&interfaces_to_take_down_size,

2292

interface);

2293

if(errno != 0){

2218

ret_errno = argz_add(&interfaces_to_take_down,

2219

&interfaces_to_take_down_size,

2220

interface);

2221

if(ret_errno != 0){

2222

errno = ret_errno;

2294

2223

perror_plus("argz_add");

2295

2224

}

2296

2225

}

2412

2341

sleep((unsigned int)retry_interval);

2413

2342

}

2414

2343

2415

if(not quit_now){

2344

if (not quit_now){

2416

2345

exitcode = EXIT_SUCCESS;

2417

2346

}

2418

2347

2520

2449

}

2521

2450

}

2522

2451

2523

/* Re-raise privileges */

2452

/* Re-raise priviliges */

2524

2453

{

2525

ret_errno = raise_privileges();

2526

if(ret_errno != 0){

2527

perror_plus("Failed to raise privileges");

2528

} else {

2529

2530

/* Run network hooks */

2531

run_network_hooks("stop", interfaces_hooks != NULL ?

2532

interfaces_hooks : "", delay);

2533

2534

/* Take down the network interfaces which were brought up */

2535

{

2536

char *interface = NULL;

2537

while((interface=argz_next(interfaces_to_take_down,

2538

interfaces_to_take_down_size,

2539

interface))){

2540

ret_errno = take_down_interface(interface);

2541

if(ret_errno != 0){

2542

errno = ret_errno;

2543

perror_plus("Failed to take down interface");

2544

}

2545

}

2546

if(debug and (interfaces_to_take_down == NULL)){

2547

fprintf_plus(stderr, "No interfaces needed to be taken"

2548

" down\n");

2549

}

2550

}

2551

}

2552

ret_errno = lower_privileges_permanently();

2553

if(ret_errno != 0){

2554

perror_plus("Failed to lower privileges permanently");

2555

}

2454

raise_privileges();

2455

2456

/* Run network hooks */

2457

run_network_hooks("stop", interfaces_hooks != NULL ?

2458

interfaces_hooks : "", delay);

2459

2460

/* Take down the network interfaces which were brought up */

2461

{

2462

char *interface = NULL;

2463

while((interface=argz_next(interfaces_to_take_down,

2464

interfaces_to_take_down_size,

2465

interface))){

2466

ret_errno = take_down_interface(interface);

2467

if(ret_errno != 0){

2468

errno = ret_errno;

2469

perror_plus("Failed to take down interface");

2470

}

2471

}

2472

if(debug and (interfaces_to_take_down == NULL)){

2473

fprintf_plus(stderr, "No interfaces needed to be taken"

2474

" down\n");

2475

}

2476

}

2477

2478

lower_privileges_permanently();

2556

2479

}

2557

2480

2558

2481

free(interfaces_to_take_down);

2564

2487

struct dirent *direntry = NULL;

2565

2488

int numentries = scandir(tempdir, &direntries, notdotentries,

2566

2489

alphasort);

2567

if(numentries > 0){

2490

if (numentries > 0){

2568

2491

for(int i = 0; i < numentries; i++){

2569

2492

direntry = direntries[i];

2570

2493

char *fullname = NULL;

2585

2508

2586

2509

/* need to clean even if 0 because man page doesn't specify */

2587

2510

free(direntries);

2588

if(numentries == -1){

2511

if (numentries == -1){

2589

2512

perror_plus("scandir");

2590

2513

}

2591

2514

ret = rmdir(tempdir);