granicus.if.org Git - apache/blob - modules/ssl/ssl_engine_config.c

   1 /*                      _             _
   2 **  _ __ ___   ___   __| |    ___ ___| |  mod_ssl
   3 ** | '_ ` _ \ / _ \ / _` |   / __/ __| |  Apache Interface to OpenSSL
   4 ** | | | | | | (_) | (_| |   \__ \__ \ |  www.modssl.org
   5 ** |_| |_| |_|\___/ \__,_|___|___/___/_|  ftp.modssl.org
   6 **                      |_____|
   7 **  ssl_engine_config.c
   8 **  Apache Configuration Directives
   9 */
  10
  11 /* ====================================================================
  12  * The Apache Software License, Version 1.1
  13  *
  14  * Copyright (c) 2000-2001 The Apache Software Foundation.  All rights
  15  * reserved.
  16  *
  17  * Redistribution and use in source and binary forms, with or without
  18  * modification, are permitted provided that the following conditions
  19  * are met:
  20  *
  21  * 1. Redistributions of source code must retain the above copyright
  22  *    notice, this list of conditions and the following disclaimer.
  23  *
  24  * 2. Redistributions in binary form must reproduce the above copyright
  25  *    notice, this list of conditions and the following disclaimer in
  26  *    the documentation and/or other materials provided with the
  27  *    distribution.
  28  *
  29  * 3. The end-user documentation included with the redistribution,
  30  *    if any, must include the following acknowledgment:
  31  *       "This product includes software developed by the
  32  *        Apache Software Foundation (http://www.apache.org/)."
  33  *    Alternately, this acknowledgment may appear in the software itself,
  34  *    if and wherever such third-party acknowledgments normally appear.
  35  *
  36  * 4. The names "Apache" and "Apache Software Foundation" must
  37  *    not be used to endorse or promote products derived from this
  38  *    software without prior written permission. For written
  39  *    permission, please contact apache@apache.org.
  40  *
  41  * 5. Products derived from this software may not be called "Apache",
  42  *    nor may "Apache" appear in their name, without prior written
  43  *    permission of the Apache Software Foundation.
  44  *
  45  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  46  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  47  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  48  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  49  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  50  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  51  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  52  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  53  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  54  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  55  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  56  * SUCH DAMAGE.
  57  * ====================================================================
  58  */
  59
  60                                       /* ``Damned if you do,
  61                                            damned if you don't.''
  62                                                -- Unknown        */
  63 #include "mod_ssl.h"
  64
  65 #if 0 /* XXX */
  66
  67 /*  _________________________________________________________________
  68 **
  69 **  Support for Global Configuration
  70 **  _________________________________________________________________
  71 */
  72
  73 void ssl_hook_AddModule(module *m)
  74 {
  75     if (m == &ssl_module) {
  76         /*
  77          * Link ourself into the Apache kernel
  78          */
  79         ssl_var_register();
  80         ssl_ext_register();
  81         ssl_io_register();
  82     }
  83     return;
  84 }
  85
  86 void ssl_hook_RemoveModule(module *m)
  87 {
  88     if (m == &ssl_module) {
  89         /*
  90          * Unlink ourself from the Apache kernel
  91          */
  92         ssl_var_unregister();
  93         ssl_ext_unregister();
  94         ssl_io_unregister();
  95     }
  96     return;
  97 }
  98
  99 void ssl_config_global_create(void)
 100 {
 101     pool *pPool;
 102     SSLModConfigRec *mc;
 103
 104     mc = ap_ctx_get(ap_global_ctx, "ssl_module");
 105     if (mc == NULL) {
 106         /*
 107          * allocate an own subpool which survives server restarts
 108          */
 109         pPool = ap_make_sub_pool(NULL);
 110         mc = (SSLModConfigRec *)ap_palloc(pPool, sizeof(SSLModConfigRec));
 111         mc->pPool = pPool;
 112         mc->bFixed = FALSE;
 113
 114         /*
 115          * initialize per-module configuration
 116          */
 117         mc->nInitCount             = 0;
 118         mc->nSessionCacheMode      = SSL_SCMODE_UNSET;
 119         mc->szSessionCacheDataFile = NULL;
 120         mc->nSessionCacheDataSize  = 0;
 121         mc->pSessionCacheDataMM    = NULL;
 122         mc->tSessionCacheDataTable = NULL;
 123         mc->nMutexMode             = SSL_MUTEXMODE_UNSET;
 124         mc->szMutexFile            = NULL;
 125         mc->nMutexFD               = -1;
 126         mc->nMutexSEMID            = -1;
 127         mc->aRandSeed              = ap_make_array(pPool, 4, sizeof(ssl_randseed_t));
 128         mc->tPrivateKey            = ssl_ds_table_make(pPool, sizeof(ssl_asn1_t));
 129         mc->tPublicCert            = ssl_ds_table_make(pPool, sizeof(ssl_asn1_t));
 130         mc->tTmpKeys               = ssl_ds_table_make(pPool, sizeof(ssl_asn1_t));
 131 #ifdef SSL_EXPERIMENTAL_ENGINE
 132         mc->szCryptoDevice         = NULL;
 133 #endif
 134
 135         (void)memset(mc->pTmpKeys, 0, SSL_TKPIDX_MAX*sizeof(void *));
 136
 137         /*
 138          * And push it into Apache's global context
 139          */
 140         ap_ctx_set(ap_global_ctx, "ssl_module", mc);
 141     }
 142     return;
 143 }
 144
 145 void ssl_config_global_fix(void)
 146 {
 147     SSLModConfigRec *mc = myModConfig();
 148     mc->bFixed = TRUE;
 149     return;
 150 }
 151
 152 BOOL ssl_config_global_isfixed(void)
 153 {
 154     SSLModConfigRec *mc = myModConfig();
 155     return (mc->bFixed);
 156 }
 157
 158
 159 /*  _________________________________________________________________
 160 **
 161 **  Configuration handling
 162 **  _________________________________________________________________
 163 */
 164
 165 /*
 166  *  Create per-server SSL configuration
 167  */
 168 void *ssl_config_server_create(pool *p, server_rec *s)
 169 {
 170     SSLSrvConfigRec *sc;
 171
 172     ssl_config_global_create();
 173
 174     sc = ap_palloc(p, sizeof(SSLSrvConfigRec));
 175     sc->bEnabled               = UNSET;
 176     sc->szCACertificatePath    = NULL;
 177     sc->szCACertificateFile    = NULL;
 178     sc->szCertificateChain     = NULL;
 179     sc->szLogFile              = NULL;
 180     sc->szCipherSuite          = NULL;
 181     sc->nLogLevel              = SSL_LOG_NONE;
 182     sc->nVerifyDepth           = UNSET;
 183     sc->nVerifyClient          = SSL_CVERIFY_UNSET;
 184     sc->nSessionCacheTimeout   = UNSET;
 185     sc->nPassPhraseDialogType  = SSL_PPTYPE_UNSET;
 186     sc->szPassPhraseDialogPath = NULL;
 187     sc->nProtocol              = SSL_PROTOCOL_ALL;
 188     sc->fileLogFile            = NULL;
 189     sc->pSSLCtx                = NULL;
 190     sc->szCARevocationPath     = NULL;
 191     sc->szCARevocationFile     = NULL;
 192     sc->pRevocationStore       = NULL;
 193
 194 #ifdef SSL_EXPERIMENTAL_PROXY
 195     sc->nProxyVerifyDepth             = UNSET;
 196     sc->szProxyCACertificatePath      = NULL;
 197     sc->szProxyCACertificateFile      = NULL;
 198     sc->szProxyClientCertificateFile  = NULL;
 199     sc->szProxyClientCertificatePath  = NULL;
 200     sc->szProxyCipherSuite            = NULL;
 201     sc->nProxyProtocol                = SSL_PROTOCOL_ALL & ~SSL_PROTOCOL_TLSV1;
 202     sc->bProxyVerify                  = UNSET;
 203     sc->pSSLProxyCtx                  = NULL;
 204 #endif
 205
 206     (void)memset(sc->szPublicCertFile, 0, SSL_AIDX_MAX*sizeof(char *));
 207     (void)memset(sc->szPrivateKeyFile, 0, SSL_AIDX_MAX*sizeof(char *));
 208     (void)memset(sc->pPublicCert, 0, SSL_AIDX_MAX*sizeof(X509 *));
 209     (void)memset(sc->pPrivateKey, 0, SSL_AIDX_MAX*sizeof(EVP_PKEY *));
 210
 211     return sc;
 212 }
 213
 214 /*
 215  *  Merge per-server SSL configurations
 216  */
 217 void *ssl_config_server_merge(pool *p, void *basev, void *addv)
 218 {
 219     SSLSrvConfigRec *base = (SSLSrvConfigRec *)basev;
 220     SSLSrvConfigRec *add  = (SSLSrvConfigRec *)addv;
 221     SSLSrvConfigRec *new  = (SSLSrvConfigRec *)ap_palloc(p, sizeof(SSLSrvConfigRec));
 222     int i;
 223
 224     cfgMergeBool(bEnabled);
 225     cfgMergeString(szCACertificatePath);
 226     cfgMergeString(szCACertificateFile);
 227     cfgMergeString(szCertificateChain);
 228     cfgMergeString(szLogFile);
 229     cfgMergeString(szCipherSuite);
 230     cfgMerge(nLogLevel, SSL_LOG_NONE);
 231     cfgMergeInt(nVerifyDepth);
 232     cfgMerge(nVerifyClient, SSL_CVERIFY_UNSET);
 233     cfgMergeInt(nSessionCacheTimeout);
 234     cfgMerge(nPassPhraseDialogType, SSL_PPTYPE_UNSET);
 235     cfgMergeString(szPassPhraseDialogPath);
 236     cfgMerge(nProtocol, SSL_PROTOCOL_ALL);
 237     cfgMerge(fileLogFile, NULL);
 238     cfgMerge(pSSLCtx, NULL);
 239     cfgMerge(szCARevocationPath, NULL);
 240     cfgMerge(szCARevocationFile, NULL);
 241     cfgMerge(pRevocationStore, NULL);
 242
 243     for (i = 0; i < SSL_AIDX_MAX; i++) {
 244         cfgMergeString(szPublicCertFile[i]);
 245         cfgMergeString(szPrivateKeyFile[i]);
 246         cfgMerge(pPublicCert[i], NULL);
 247         cfgMerge(pPrivateKey[i], NULL);
 248     }
 249
 250 #ifdef SSL_EXPERIMENTAL_PROXY
 251     cfgMergeInt(nProxyVerifyDepth);
 252     cfgMergeString(szProxyCACertificatePath);
 253     cfgMergeString(szProxyCACertificateFile);
 254     cfgMergeString(szProxyClientCertificateFile);
 255     cfgMergeString(szProxyClientCertificatePath);
 256     cfgMergeString(szProxyCipherSuite);
 257     cfgMerge(nProxyProtocol, (SSL_PROTOCOL_ALL & ~SSL_PROTOCOL_TLSV1));
 258     cfgMergeBool(bProxyVerify);
 259     cfgMerge(pSSLProxyCtx, NULL);
 260 #endif
 261
 262     return new;
 263 }
 264
 265 /*
 266  *  Create per-directory SSL configuration
 267  */
 268 void *ssl_config_perdir_create(pool *p, char *dir)
 269 {
 270     SSLDirConfigRec *dc = ap_palloc(p, sizeof(SSLDirConfigRec));
 271
 272     dc->bSSLRequired  = FALSE;
 273     dc->aRequirement  = ap_make_array(p, 4, sizeof(ssl_require_t));
 274     dc->nOptions      = SSL_OPT_NONE|SSL_OPT_RELSET;
 275     dc->nOptionsAdd   = SSL_OPT_NONE;
 276     dc->nOptionsDel   = SSL_OPT_NONE;
 277
 278     dc->szCipherSuite          = NULL;
 279     dc->nVerifyClient          = SSL_CVERIFY_UNSET;
 280     dc->nVerifyDepth           = UNSET;
 281 #ifdef SSL_EXPERIMENTAL_PERDIRCA
 282     dc->szCACertificatePath    = NULL;
 283     dc->szCACertificateFile    = NULL;
 284 #endif
 285
 286     return dc;
 287 }
 288
 289 /*
 290  *  Merge per-directory SSL configurations
 291  */
 292 void *ssl_config_perdir_merge(pool *p, void *basev, void *addv)
 293 {
 294     SSLDirConfigRec *base = (SSLDirConfigRec *)basev;
 295     SSLDirConfigRec *add  = (SSLDirConfigRec *)addv;
 296     SSLDirConfigRec *new  = (SSLDirConfigRec *)ap_palloc(p,
 297                                                sizeof(SSLDirConfigRec));
 298
 299     cfgMerge(bSSLRequired, FALSE);
 300     cfgMergeArray(aRequirement);
 301
 302     if (add->nOptions & SSL_OPT_RELSET) {
 303         new->nOptionsAdd = (base->nOptionsAdd & ~(add->nOptionsDel)) | add->nOptionsAdd;
 304         new->nOptionsDel = (base->nOptionsDel & ~(add->nOptionsAdd)) | add->nOptionsDel;
 305         new->nOptions    = (base->nOptions    & ~(new->nOptionsDel)) | new->nOptionsAdd;
 306     }
 307     else {
 308         new->nOptions    = add->nOptions;
 309         new->nOptionsAdd = add->nOptionsAdd;
 310         new->nOptionsDel = add->nOptionsDel;
 311     }
 312
 313     cfgMergeString(szCipherSuite);
 314     cfgMerge(nVerifyClient, SSL_CVERIFY_UNSET);
 315     cfgMergeInt(nVerifyDepth);
 316 #ifdef SSL_EXPERIMENTAL_PERDIRCA
 317     cfgMergeString(szCACertificatePath);
 318     cfgMergeString(szCACertificateFile);
 319 #endif
 320
 321     return new;
 322 }
 323
 324 #endif /* XXX */
 325
 326 /*
 327  *  Configuration functions for particular directives
 328  */
 329
 330 const char *ssl_cmd_SSLMutex(
 331     cmd_parms *cmd, char *struct_ptr, char *arg)
 332 {
 333 #if 0 /* XXX */
 334     const char *err;
 335     SSLModConfigRec *mc = myModConfig();
 336
 337     if ((err = ap_check_cmd_context(cmd, GLOBAL_ONLY)) != NULL)
 338         return err;
 339     if (ssl_config_global_isfixed())
 340         return NULL;
 341     if (strcEQ(arg, "none")) {
 342         mc->nMutexMode  = SSL_MUTEXMODE_NONE;
 343     }
 344     else if (strlen(arg) > 5 && strcEQn(arg, "file:", 5)) {
 345         mc->nMutexMode  = SSL_MUTEXMODE_FILE;
 346         mc->szMutexFile = ap_psprintf(mc->pPool, "%s.%lu",
 347                                       ap_server_root_relative(cmd->pool, "mutex", arg+5),
 348                                       (unsigned long)getpid());
 349     }
 350     else if (strcEQ(arg, "sem")) {
 351 #ifdef SSL_CAN_USE_SEM
 352         mc->nMutexMode  = SSL_MUTEXMODE_SEM;
 353 #else
 354         return "SSLMutex: Semaphores not available on this platform";
 355 #endif
 356     }
 357     else
 358         return "SSLMutex: Invalid argument";
 359 #endif /* XXX */
 360     return NULL;
 361 }
 362
 363 const char *ssl_cmd_SSLPassPhraseDialog(
 364     cmd_parms *cmd, char *struct_ptr, char *arg)
 365 {
 366 #if 0 /* XXX */
 367     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 368     const char *err;
 369
 370     if ((err = ap_check_cmd_context(cmd, GLOBAL_ONLY)) != NULL)
 371         return err;
 372     if (strcEQ(arg, "builtin")) {
 373         sc->nPassPhraseDialogType  = SSL_PPTYPE_BUILTIN;
 374         sc->szPassPhraseDialogPath = NULL;
 375     }
 376     else if (strlen(arg) > 5 && strEQn(arg, "exec:", 5)) {
 377         sc->nPassPhraseDialogType  = SSL_PPTYPE_FILTER;
 378         sc->szPassPhraseDialogPath = ap_server_root_relative(cmd->pool, "dialog", arg+5);
 379         if (!ssl_util_path_check(SSL_PCM_EXISTS, sc->szPassPhraseDialogPath))
 380             return ap_pstrcat(cmd->pool, "SSLPassPhraseDialog: file '",
 381                               sc->szPassPhraseDialogPath, "' not exists", NULL);
 382     }
 383     else
 384         return "SSLPassPhraseDialog: Invalid argument";
 385 #endif /* XXX */
 386     return NULL;
 387 }
 388
 389 #ifdef SSL_EXPERIMENTAL_ENGINE
 390 const char *ssl_cmd_SSLCryptoDevice(
 391     cmd_parms *cmd, char *struct_ptr, char *arg)
 392 {
 393 #if 0 /* XXX */
 394     SSLModConfigRec *mc = myModConfig();
 395     const char *err;
 396     ENGINE *e;
 397 #if SSL_LIBRARY_VERSION >= 0x00907000
 398     static int loaded_engines = FALSE;
 399
 400     /* early loading to make sure the engines are already
 401        available for ENGINE_by_id() above... */
 402     if (!loaded_engines) {
 403         ENGINE_load_builtin_engines();
 404         loaded_engines = TRUE;
 405     }
 406 #endif
 407     if ((err = ap_check_cmd_context(cmd, GLOBAL_ONLY)) != NULL)
 408         return err;
 409     if (strcEQ(arg, "builtin")) {
 410         mc->szCryptoDevice = NULL;
 411     }
 412     else if ((e = ENGINE_by_id(arg)) != NULL) {
 413         mc->szCryptoDevice = arg;
 414         ENGINE_free(e);
 415     }
 416     else
 417         return "SSLCryptoDevice: Invalid argument";
 418 #endif /* XXX */
 419     return NULL;
 420 }
 421 #endif
 422
 423 const char *ssl_cmd_SSLRandomSeed(
 424     cmd_parms *cmd, char *struct_ptr, char *arg1, char *arg2, char *arg3)
 425 {
 426 #if 0 /* XXX */
 427     SSLModConfigRec *mc = myModConfig();
 428     const char *err;
 429     ssl_randseed_t *pRS;
 430
 431     if ((err = ap_check_cmd_context(cmd, GLOBAL_ONLY)) != NULL)
 432         return err;
 433     if (ssl_config_global_isfixed())
 434         return NULL;
 435     pRS = ap_push_array(mc->aRandSeed);
 436     if (strcEQ(arg1, "startup"))
 437         pRS->nCtx = SSL_RSCTX_STARTUP;
 438     else if (strcEQ(arg1, "connect"))
 439         pRS->nCtx = SSL_RSCTX_CONNECT;
 440     else
 441         return ap_pstrcat(cmd->pool, "SSLRandomSeed: "
 442                           "invalid context: `", arg1, "'");
 443     if (strlen(arg2) > 5 && strEQn(arg2, "file:", 5)) {
 444         pRS->nSrc   = SSL_RSSRC_FILE;
 445         pRS->cpPath = ap_pstrdup(mc->pPool, ap_server_root_relative(cmd->pool, "random", arg2+5));
 446     }
 447     else if (strlen(arg2) > 5 && strEQn(arg2, "exec:", 5)) {
 448         pRS->nSrc   = SSL_RSSRC_EXEC;
 449         pRS->cpPath = ap_pstrdup(mc->pPool, ap_server_root_relative(cmd->pool, "random", arg2+5));
 450     }
 451 #if SSL_LIBRARY_VERSION >= 0x00905100
 452     else if (strlen(arg2) > 4 && strEQn(arg2, "egd:", 4)) {
 453         pRS->nSrc   = SSL_RSSRC_EGD;
 454         pRS->cpPath = ap_pstrdup(mc->pPool, ap_server_root_relative(cmd->pool, "random", arg2+4));
 455     }
 456 #endif
 457     else if (strcEQ(arg2, "builtin")) {
 458         pRS->nSrc   = SSL_RSSRC_BUILTIN;
 459         pRS->cpPath = NULL;
 460     }
 461     else {
 462         pRS->nSrc   = SSL_RSSRC_FILE;
 463         pRS->cpPath = ap_pstrdup(mc->pPool, ap_server_root_relative(cmd->pool, "random", arg2));
 464     }
 465     if (pRS->nSrc != SSL_RSSRC_BUILTIN)
 466         if (!ssl_util_path_check(SSL_PCM_EXISTS, pRS->cpPath))
 467             return ap_pstrcat(cmd->pool, "SSLRandomSeed: source path '",
 468                               pRS->cpPath, "' not exists", NULL);
 469     if (arg3 == NULL)
 470         pRS->nBytes = 0; /* read whole file */
 471     else {
 472         if (pRS->nSrc == SSL_RSSRC_BUILTIN)
 473             return "SSLRandomSeed: byte specification not "
 474                    "allowed for builtin seed source";
 475         pRS->nBytes = atoi(arg3);
 476         if (pRS->nBytes < 0)
 477             return "SSLRandomSeed: invalid number of bytes specified";
 478     }
 479 #endif /* XXX */
 480     return NULL;
 481 }
 482
 483 const char *ssl_cmd_SSLEngine(
 484     cmd_parms *cmd, char *struct_ptr, int flag)
 485 {
 486 #if 0 /* XXX */
 487     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 488
 489     sc->bEnabled = (flag ? TRUE : FALSE);
 490 #endif /* XXX */
 491     return NULL;
 492 }
 493
 494 const char *ssl_cmd_SSLCipherSuite(
 495     cmd_parms *cmd, SSLDirConfigRec *dc, char *arg)
 496 {
 497 #if 0 /* XXX */
 498     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 499
 500     if (cmd->path == NULL || dc == NULL)
 501         sc->szCipherSuite = arg;
 502     else
 503         dc->szCipherSuite = arg;
 504 #endif /* XXX */
 505     return NULL;
 506 }
 507
 508 const char *ssl_cmd_SSLCertificateFile(
 509     cmd_parms *cmd, char *struct_ptr, char *arg)
 510 {
 511 #if 0 /* XXX */
 512     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 513     char *cpPath;
 514     int i;
 515
 516     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
 517     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISREG|SSL_PCM_ISNONZERO, cpPath))
 518         return ap_pstrcat(cmd->pool, "SSLCertificateFile: file '",
 519                           cpPath, "' not exists or empty", NULL);
 520     for (i = 0; i < SSL_AIDX_MAX && sc->szPublicCertFile[i] != NULL; i++)
 521         ;
 522     if (i == SSL_AIDX_MAX)
 523         return ap_psprintf(cmd->pool, "SSLCertificateFile: only up to %d "
 524                           "different certificates per virtual host allowed",
 525                           SSL_AIDX_MAX);
 526     sc->szPublicCertFile[i] = cpPath;
 527 #endif /* XXX */
 528     return NULL;
 529 }
 530
 531 const char *ssl_cmd_SSLCertificateKeyFile(
 532     cmd_parms *cmd, char *struct_ptr, char *arg)
 533 {
 534 #if 0 /* XXX */
 535     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 536     char *cpPath;
 537     int i;
 538
 539     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
 540     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISREG|SSL_PCM_ISNONZERO, cpPath))
 541         return ap_pstrcat(cmd->pool, "SSLCertificateKeyFile: file '",
 542                           cpPath, "' not exists or empty", NULL);
 543     for (i = 0; i < SSL_AIDX_MAX && sc->szPrivateKeyFile[i] != NULL; i++)
 544         ;
 545     if (i == SSL_AIDX_MAX)
 546         return ap_psprintf(cmd->pool, "SSLCertificateKeyFile: only up to %d "
 547                           "different private keys per virtual host allowed",
 548                           SSL_AIDX_MAX);
 549     sc->szPrivateKeyFile[i] = cpPath;
 550 #endif /* XXX */
 551     return NULL;
 552 }
 553
 554 const char *ssl_cmd_SSLCertificateChainFile(
 555     cmd_parms *cmd, char *struct_ptr, char *arg)
 556 {
 557 #if 0 /* XXX */
 558     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 559     char *cpPath;
 560
 561     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
 562     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISREG|SSL_PCM_ISNONZERO, cpPath))
 563         return ap_pstrcat(cmd->pool, "SSLCertificateChainFile: file '",
 564                           cpPath, "' not exists or empty", NULL);
 565     sc->szCertificateChain = cpPath;
 566 #endif /* XXX */
 567     return NULL;
 568 }
 569
 570 const char *ssl_cmd_SSLCACertificatePath(
 571     cmd_parms *cmd, SSLDirConfigRec *dc, char *arg)
 572 {
 573 #if 0 /* XXX */
 574     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 575     char *cpPath;
 576
 577     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
 578     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISDIR, cpPath))
 579         return ap_pstrcat(cmd->pool, "SSLCACertificatePath: directory '",
 580                           cpPath, "' not exists", NULL);
 581 #ifdef SSL_EXPERIMENTAL_PERDIRCA
 582     if (cmd->path == NULL || dc == NULL)
 583         sc->szCACertificatePath = cpPath;
 584     else
 585         dc->szCACertificatePath = cpPath;
 586 #else
 587     sc->szCACertificatePath = cpPath;
 588 #endif
 589 #endif /* XXX */
 590     return NULL;
 591 }
 592
 593 const char *ssl_cmd_SSLCACertificateFile(
 594     cmd_parms *cmd, SSLDirConfigRec *dc, char *arg)
 595 {
 596 #if 0 /* XXX */
 597     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 598     char *cpPath;
 599
 600     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
 601     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISREG|SSL_PCM_ISNONZERO, cpPath))
 602         return ap_pstrcat(cmd->pool, "SSLCACertificateFile: file '",
 603                           cpPath, "' not exists or empty", NULL);
 604 #ifdef SSL_EXPERIMENTAL_PERDIRCA
 605     if (cmd->path == NULL || dc == NULL)
 606         sc->szCACertificateFile = cpPath;
 607     else
 608         dc->szCACertificateFile = cpPath;
 609 #else
 610     sc->szCACertificateFile = cpPath;
 611 #endif
 612 #endif /* XXX */
 613     return NULL;
 614 }
 615
 616 const char *ssl_cmd_SSLCARevocationPath(
 617     cmd_parms *cmd, SSLDirConfigRec *dc, char *arg)
 618 {
 619 #if 0 /* XXX */
 620     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 621     char *cpPath;
 622
 623     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
 624     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISDIR, cpPath))
 625         return ap_pstrcat(cmd->pool, "SSLCARecocationPath: directory '",
 626                           cpPath, "' not exists", NULL);
 627     sc->szCARevocationPath = cpPath;
 628 #endif /* XXX */
 629     return NULL;
 630 }
 631
 632 const char *ssl_cmd_SSLCARevocationFile(
 633     cmd_parms *cmd, SSLDirConfigRec *dc, char *arg)
 634 {
 635 #if 0 /* XXX */
 636     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 637     char *cpPath;
 638
 639     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
 640     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISREG|SSL_PCM_ISNONZERO, cpPath))
 641         return ap_pstrcat(cmd->pool, "SSLCARevocationFile: file '",
 642                           cpPath, "' not exists or empty", NULL);
 643     sc->szCARevocationFile = cpPath;
 644 #endif /* XXX */
 645     return NULL;
 646 }
 647
 648 const char *ssl_cmd_SSLVerifyClient(
 649     cmd_parms *cmd, SSLDirConfigRec *dc, char *level)
 650 {
 651 #if 0 /* XXX */
 652     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 653     ssl_verify_t id;
 654
 655     if (strEQ(level, "0") || strcEQ(level, "none"))
 656         id = SSL_CVERIFY_NONE;
 657     else if (strEQ(level, "1") || strcEQ(level, "optional"))
 658         id = SSL_CVERIFY_OPTIONAL;
 659     else if (strEQ(level, "2") || strcEQ(level, "require"))
 660         id = SSL_CVERIFY_REQUIRE;
 661     else if (strEQ(level, "3") || strcEQ(level, "optional_no_ca"))
 662         id = SSL_CVERIFY_OPTIONAL_NO_CA;
 663     else
 664         return "SSLVerifyClient: Invalid argument";
 665     if (cmd->path == NULL || dc == NULL)
 666         sc->nVerifyClient = id;
 667     else
 668         dc->nVerifyClient = id;
 669 #endif /* XXX */
 670     return NULL;
 671 }
 672
 673 const char *ssl_cmd_SSLVerifyDepth(
 674     cmd_parms *cmd, SSLDirConfigRec *dc, char *arg)
 675 {
 676 #if 0 /* XXX */
 677     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 678     int d;
 679
 680     d = atoi(arg);
 681     if (d < 0)
 682         return "SSLVerifyDepth: Invalid argument";
 683     if (cmd->path == NULL || dc == NULL)
 684         sc->nVerifyDepth = d;
 685     else
 686         dc->nVerifyDepth = d;
 687 #endif /* XXX */
 688     return NULL;
 689 }
 690
 691 const char *ssl_cmd_SSLSessionCache(
 692     cmd_parms *cmd, char *struct_ptr, char *arg)
 693 {
 694 #if 0 /* XXX */
 695     const char *err;
 696     SSLModConfigRec *mc = myModConfig();
 697     char *cp, *cp2;
 698     int maxsize;
 699
 700     if ((err = ap_check_cmd_context(cmd, GLOBAL_ONLY)) != NULL)
 701         return err;
 702     if (ssl_config_global_isfixed())
 703         return NULL;
 704     if (strcEQ(arg, "none")) {
 705         mc->nSessionCacheMode      = SSL_SCMODE_NONE;
 706         mc->szSessionCacheDataFile = NULL;
 707     }
 708     else if (strlen(arg) > 4 && strcEQn(arg, "dbm:", 4)) {
 709         mc->nSessionCacheMode      = SSL_SCMODE_DBM;
 710         mc->szSessionCacheDataFile = ap_pstrdup(mc->pPool,
 711                                      ap_server_root_relative(cmd->pool, "scache", arg+4));
 712     }
 713     else if (   (strlen(arg) > 4 && strcEQn(arg, "shm:",   4))
 714              || (strlen(arg) > 6 && strcEQn(arg, "shmht:", 6))) {
 715         if (!ap_mm_useable())
 716             return "SSLSessionCache: shared memory cache not useable on this platform";
 717         mc->nSessionCacheMode      = SSL_SCMODE_SHMHT;
 718         cp = strchr(arg, ':');
 719         mc->szSessionCacheDataFile = ap_pstrdup(mc->pPool,
 720                                      ap_server_root_relative(cmd->pool, "scache", cp+1));
 721         mc->tSessionCacheDataTable = NULL;
 722         mc->nSessionCacheDataSize  = 1024*512; /* 512KB */
 723         if ((cp = strchr(mc->szSessionCacheDataFile, '(')) != NULL) {
 724             *cp++ = NUL;
 725             if ((cp2 = strchr(cp, ')')) == NULL)
 726                 return "SSLSessionCache: Invalid argument: no closing parenthesis";
 727             *cp2 = NUL;
 728             mc->nSessionCacheDataSize = atoi(cp);
 729             if (mc->nSessionCacheDataSize <= 8192)
 730                 return "SSLSessionCache: Invalid argument: size has to be >= 8192 bytes";
 731             maxsize = ap_mm_core_maxsegsize();
 732             if (mc->nSessionCacheDataSize >= maxsize)
 733                 return ap_psprintf(cmd->pool, "SSLSessionCache: Invalid argument: "
 734                                    "size has to be < %d bytes on this platform", maxsize);
 735         }
 736     }
 737     else if (strlen(arg) > 6 && strcEQn(arg, "shmcb:", 6)) {
 738         if (!ap_mm_useable())
 739             return "SSLSessionCache: shared memory cache not useable on this platform";
 740         mc->nSessionCacheMode      = SSL_SCMODE_SHMCB;
 741         mc->szSessionCacheDataFile = ap_pstrdup(mc->pPool,
 742                                      ap_server_root_relative(cmd->pool, arg+6));
 743         mc->tSessionCacheDataTable = NULL;
 744         mc->nSessionCacheDataSize  = 1024*512; /* 512KB */
 745         if ((cp = strchr(mc->szSessionCacheDataFile, '(')) != NULL) {
 746             *cp++ = NUL;
 747             if ((cp2 = strchr(cp, ')')) == NULL)
 748                 return "SSLSessionCache: Invalid argument: no closing parenthesis";
 749             *cp2 = NUL;
 750             mc->nSessionCacheDataSize = atoi(cp);
 751             if (mc->nSessionCacheDataSize <= 8192)
 752                 return "SSLSessionCache: Invalid argument: size has to be >= 8192 bytes";
 753             maxsize = ap_mm_core_maxsegsize();
 754             if (mc->nSessionCacheDataSize >= maxsize)
 755                 return ap_psprintf(cmd->pool, "SSLSessionCache: Invalid argument: "
 756                                    "size has to be < %d bytes on this platform", maxsize);
 757         }
 758     }
 759         else
 760         return "SSLSessionCache: Invalid argument";
 761 #endif /* XXX */
 762     return NULL;
 763 }
 764
 765 const char *ssl_cmd_SSLSessionCacheTimeout(
 766     cmd_parms *cmd, char *struct_ptr, char *arg)
 767 {
 768 #if 0 /* XXX */
 769     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 770
 771     sc->nSessionCacheTimeout = atoi(arg);
 772     if (sc->nSessionCacheTimeout < 0)
 773         return "SSLSessionCacheTimeout: Invalid argument";
 774 #endif /* XXX */
 775     return NULL;
 776 }
 777
 778 const char *ssl_cmd_SSLLog(
 779     cmd_parms *cmd, char *struct_ptr, char *arg)
 780 {
 781 #if 0 /* XXX */
 782     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 783     const char *err;
 784
 785     if ((err = ap_check_cmd_context(cmd,  NOT_IN_LIMIT|NOT_IN_DIRECTORY
 786                                          |NOT_IN_LOCATION|NOT_IN_FILES )) != NULL)
 787         return err;
 788     sc->szLogFile = arg;
 789 #endif /* XXX */
 790     return NULL;
 791 }
 792
 793 const char *ssl_cmd_SSLLogLevel(
 794     cmd_parms *cmd, char *struct_ptr, char *level)
 795 {
 796 #if 0 /* XXX */
 797     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 798     const char *err;
 799
 800     if ((err = ap_check_cmd_context(cmd,  NOT_IN_LIMIT|NOT_IN_DIRECTORY
 801                                          |NOT_IN_LOCATION|NOT_IN_FILES )) != NULL)
 802         return err;
 803     if (strcEQ(level, "none"))
 804         sc->nLogLevel = SSL_LOG_NONE;
 805     else if (strcEQ(level, "error"))
 806         sc->nLogLevel = SSL_LOG_ERROR;
 807     else if (strcEQ(level, "warn"))
 808         sc->nLogLevel = SSL_LOG_WARN;
 809     else if (strcEQ(level, "info"))
 810         sc->nLogLevel = SSL_LOG_INFO;
 811     else if (strcEQ(level, "trace"))
 812         sc->nLogLevel = SSL_LOG_TRACE;
 813     else if (strcEQ(level, "debug"))
 814         sc->nLogLevel = SSL_LOG_DEBUG;
 815     else
 816         return "SSLLogLevel: Invalid argument";
 817 #endif /* XXX */
 818     return NULL;
 819 }
 820
 821 const char *ssl_cmd_SSLOptions(
 822     cmd_parms *cmd, SSLDirConfigRec *dc, const char *cpLine)
 823 {
 824 #if 0 /* XXX */
 825     ssl_opt_t opt;
 826     int first;
 827     char action;
 828     char *w;
 829
 830     first = TRUE;
 831     while (cpLine[0] != NUL) {
 832         w = ap_getword_conf(cmd->pool, &cpLine);
 833         action = NUL;
 834
 835         if (*w == '+' || *w == '-') {
 836             action = *(w++);
 837         }
 838         else if (first) {
 839             dc->nOptions = SSL_OPT_NONE;
 840             first = FALSE;
 841         }
 842
 843         if (strcEQ(w, "StdEnvVars"))
 844             opt = SSL_OPT_STDENVVARS;
 845         else if (strcEQ(w, "CompatEnvVars"))
 846             opt = SSL_OPT_COMPATENVVARS;
 847         else if (strcEQ(w, "ExportCertData"))
 848             opt = SSL_OPT_EXPORTCERTDATA;
 849         else if (strcEQ(w, "FakeBasicAuth"))
 850             opt = SSL_OPT_FAKEBASICAUTH;
 851         else if (strcEQ(w, "StrictRequire"))
 852             opt = SSL_OPT_STRICTREQUIRE;
 853         else if (strcEQ(w, "OptRenegotiate"))
 854             opt = SSL_OPT_OPTRENEGOTIATE;
 855         else
 856             return ap_pstrcat(cmd->pool, "SSLOptions: Illegal option '", w, "'", NULL);
 857
 858         if (action == '-') {
 859             dc->nOptionsAdd &= ~opt;
 860             dc->nOptionsDel |=  opt;
 861             dc->nOptions    &= ~opt;
 862         }
 863         else if (action == '+') {
 864             dc->nOptionsAdd |=  opt;
 865             dc->nOptionsDel &= ~opt;
 866             dc->nOptions    |=  opt;
 867         }
 868         else {
 869             dc->nOptions    = opt;
 870             dc->nOptionsAdd = opt;
 871             dc->nOptionsDel = SSL_OPT_NONE;
 872         }
 873     }
 874 #endif /* XXX */
 875     return NULL;
 876 }
 877
 878 const char *ssl_cmd_SSLRequireSSL(
 879     cmd_parms *cmd, SSLDirConfigRec *dc, char *cipher)
 880 {
 881 #if 0 /* XXX */
 882     dc->bSSLRequired = TRUE;
 883 #endif /* XXX */
 884     return NULL;
 885 }
 886
 887 const char *ssl_cmd_SSLRequire(
 888     cmd_parms *cmd, SSLDirConfigRec *dc, char *cpExpr)
 889 {
 890 #if 0 /* XXX */
 891     ssl_expr *mpExpr;
 892     ssl_require_t *pReqRec;
 893
 894     if ((mpExpr = ssl_expr_comp(cmd->pool, cpExpr)) == NULL)
 895         return ap_pstrcat(cmd->pool, "SSLRequire: ", ssl_expr_get_error(), NULL);
 896     pReqRec = ap_push_array(dc->aRequirement);
 897     pReqRec->cpExpr = ap_pstrdup(cmd->pool, cpExpr);
 898     pReqRec->mpExpr = mpExpr;
 899 #endif /* XXX */
 900     return NULL;
 901 }
 902
 903 const char *ssl_cmd_SSLProtocol(
 904     cmd_parms *cmd, char *struct_ptr, const char *opt)
 905 {
 906 #if 0 /* XXX */
 907     SSLSrvConfigRec *sc;
 908     ssl_proto_t options, thisopt;
 909     char action;
 910     char *w;
 911
 912     sc = mySrvConfig(cmd->server);
 913     options = SSL_PROTOCOL_NONE;
 914     while (opt[0] != NUL) {
 915         w = ap_getword_conf(cmd->pool, &opt);
 916
 917         action = NUL;
 918         if (*w == '+' || *w == '-')
 919             action = *(w++);
 920
 921         if (strcEQ(w, "SSLv2"))
 922             thisopt = SSL_PROTOCOL_SSLV2;
 923         else if (strcEQ(w, "SSLv3"))
 924             thisopt = SSL_PROTOCOL_SSLV3;
 925         else if (strcEQ(w, "TLSv1"))
 926             thisopt = SSL_PROTOCOL_TLSV1;
 927         else if (strcEQ(w, "all"))
 928             thisopt = SSL_PROTOCOL_ALL;
 929         else
 930             return ap_pstrcat(cmd->pool, "SSLProtocol: Illegal protocol '", w, "'", NULL);
 931
 932         if (action == '-')
 933             options &= ~thisopt;
 934         else if (action == '+')
 935             options |= thisopt;
 936         else
 937             options = thisopt;
 938     }
 939     sc->nProtocol = options;
 940 #endif /* XXX */
 941     return NULL;
 942 }
 943
 944 #ifdef SSL_EXPERIMENTAL_PROXY
 945
 946 const char *ssl_cmd_SSLProxyProtocol(
 947     cmd_parms *cmd, char *struct_ptr, const char *opt)
 948 {
 949 #if 0 /* XXX */
 950     SSLSrvConfigRec *sc;
 951     ssl_proto_t options, thisopt;
 952     char action;
 953     char *w;
 954
 955     sc = mySrvConfig(cmd->server);
 956     options = SSL_PROTOCOL_NONE;
 957     while (opt[0] != NUL) {
 958         w = ap_getword_conf(cmd->pool, &opt);
 959
 960         action = NUL;
 961         if (*w == '+' || *w == '-')
 962             action = *(w++);
 963
 964         if (strcEQ(w, "SSLv2"))
 965             thisopt = SSL_PROTOCOL_SSLV2;
 966         else if (strcEQ(w, "SSLv3"))
 967             thisopt = SSL_PROTOCOL_SSLV3;
 968         else if (strcEQ(w, "TLSv1"))
 969             thisopt = SSL_PROTOCOL_TLSV1;
 970         else if (strcEQ(w, "all"))
 971             thisopt = SSL_PROTOCOL_ALL;
 972         else
 973             return ap_pstrcat(cmd->pool, "SSLProxyProtocol: "
 974                               "Illegal protocol '", w, "'", NULL);
 975         if (action == '-')
 976             options &= ~thisopt;
 977         else if (action == '+')
 978             options |= thisopt;
 979         else
 980             options = thisopt;
 981     }
 982     sc->nProxyProtocol = options;
 983 #endif /* XXX */
 984     return NULL;
 985 }
 986
 987 const char *ssl_cmd_SSLProxyCipherSuite(
 988     cmd_parms *cmd, char *struct_ptr, char *arg)
 989 {
 990 #if 0 /* XXX */
 991     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
 992
 993     sc->szProxyCipherSuite = arg;
 994 #endif /* XXX */
 995     return NULL;
 996 }
 997
 998 const char *ssl_cmd_SSLProxyVerify(
 999     cmd_parms *cmd, char *struct_ptr, int flag)
1000 {
1001 #if 0 /* XXX */
1002     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
1003
1004     sc->bProxyVerify = (flag ? TRUE : FALSE);
1005 #endif /* XXX */
1006     return NULL;
1007 }
1008
1009 const char *ssl_cmd_SSLProxyVerifyDepth(
1010     cmd_parms *cmd, char *struct_ptr, char *arg)
1011 {
1012 #if 0 /* XXX */
1013     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
1014     int d;
1015
1016     d = atoi(arg);
1017     if (d < 0)
1018         return "SSLProxyVerifyDepth: Invalid argument";
1019     sc->nProxyVerifyDepth = d;
1020 #endif /* XXX */
1021     return NULL;
1022 }
1023
1024 const char *ssl_cmd_SSLProxyCACertificateFile(
1025     cmd_parms *cmd, char *struct_ptr, char *arg)
1026 {
1027 #if 0 /* XXX */
1028     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
1029     char *cpPath;
1030
1031     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
1032     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISREG|SSL_PCM_ISNONZERO, cpPath))
1033         return ap_pstrcat(cmd->pool, "SSLProxyCACertificateFile: file '",
1034                           cpPath, "' not exists or empty", NULL);
1035     sc->szProxyCACertificateFile = cpPath;
1036 #endif /* XXX */
1037     return NULL;
1038 }
1039
1040 const char *ssl_cmd_SSLProxyCACertificatePath(
1041     cmd_parms *cmd, char *struct_ptr, char *arg)
1042 {
1043 #if 0 /* XXX */
1044     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
1045     char *cpPath;
1046
1047     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
1048     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISDIR, cpPath))
1049         return ap_pstrcat(cmd->pool, "SSLProxyCACertificatePath: directory '",
1050                           cpPath, "' does not exists", NULL);
1051     sc->szProxyCACertificatePath = cpPath;
1052 #endif /* XXX */
1053     return NULL;
1054 }
1055
1056 const char *ssl_cmd_SSLProxyMachineCertificateFile(
1057     cmd_parms *cmd, char *struct_ptr, char *arg)
1058 {
1059 #if 0 /* XXX */
1060     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
1061     char *cpPath;
1062
1063     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
1064     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISREG|SSL_PCM_ISNONZERO, cpPath))
1065         return ap_pstrcat(cmd->pool, "SSLProxyMachineCertFile: file '",
1066                           cpPath, "' not exists or empty", NULL);
1067     sc->szProxyClientCertificateFile = cpPath;
1068 #endif /* XXX */
1069     return NULL;
1070 }
1071
1072 const char *ssl_cmd_SSLProxyMachineCertificatePath(
1073     cmd_parms *cmd, char *struct_ptr, char *arg)
1074 {
1075 #if 0 /* XXX */
1076     SSLSrvConfigRec *sc = mySrvConfig(cmd->server);
1077     char *cpPath;
1078
1079     cpPath = ap_server_root_relative(cmd->pool, "certkey", arg);
1080     if (!ssl_util_path_check(SSL_PCM_EXISTS|SSL_PCM_ISDIR, cpPath))
1081         return ap_pstrcat(cmd->pool, "SSLProxyMachineCertPath: directory '",
1082                           cpPath, "' does not exists", NULL);
1083     sc->szProxyClientCertificatePath = cpPath;
1084 #endif /* XXX */
1085     return NULL;
1086 }
1087
1088 #endif /* SSL_EXPERIMENTAL_PROXY */
1089