projects/stargazer/plugins/other/radius/radius.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  19  */
  20
  21 /*
  22  *  This file contains a realization of radius data access plugin for Stargazer
  23  *
  24  *  $Revision: 1.14 $
  25  *  $Date: 2009/12/13 14:17:13 $
  26  *
  27  */
  28
  29 #include <csignal>
  30 #include <cerrno>
  31 #include <algorithm>
  32
  33 #include "stg/store.h"
  34 #include "stg/common.h"
  35 #include "stg/user_conf.h"
  36 #include "stg/user_property.h"
  37 #include "radius.h"
  38
  39 extern volatile const time_t stgTime;
  40
  41 void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password);
  42 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
  43 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
  44
  45 //-----------------------------------------------------------------------------
  46 //-----------------------------------------------------------------------------
  47 //-----------------------------------------------------------------------------
  48 class RAD_CREATOR {
  49 private:
  50     RADIUS * rad;
  51
  52 public:
  53     RAD_CREATOR()
  54         : rad(new RADIUS())
  55         {
  56         }
  57     ~RAD_CREATOR()
  58         {
  59         delete rad;
  60         }
  61
  62     RADIUS * GetPlugin()
  63         {
  64         return rad;
  65         }
  66 };
  67 //-----------------------------------------------------------------------------
  68 //-----------------------------------------------------------------------------
  69 //-----------------------------------------------------------------------------
  70 RAD_CREATOR radc;
  71 //-----------------------------------------------------------------------------
  72 //-----------------------------------------------------------------------------
  73 //-----------------------------------------------------------------------------
  74 PLUGIN * GetPlugin()
  75 {
  76 return radc.GetPlugin();
  77 }
  78 //-----------------------------------------------------------------------------
  79 //-----------------------------------------------------------------------------
  80 //-----------------------------------------------------------------------------
  81 int RAD_SETTINGS::ParseIntInRange(const std::string & str, int min, int max, int * val)
  82 {
  83 if (str2x(str.c_str(), *val))
  84     {
  85     errorStr = "Incorrect value \'" + str + "\'.";
  86     return -1;
  87     }
  88 if (*val < min || *val > max)
  89     {
  90     errorStr = "Value \'" + str + "\' out of range.";
  91     return -1;
  92     }
  93 return 0;
  94 }
  95 //-----------------------------------------------------------------------------
  96 int RAD_SETTINGS::ParseServices(const std::vector<std::string> & str, std::list<std::string> * lst)
  97 {
  98 std::copy(str.begin(), str.end(), std::back_inserter(*lst));
  99 std::list<std::string>::iterator it(std::find(lst->begin(),
 100                                lst->end(),
 101                                "empty"));
 102 if (it != lst->end())
 103     *it = "";
 104
 105 return 0;
 106 }
 107 //-----------------------------------------------------------------------------
 108 int RAD_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
 109 {
 110 int p;
 111 PARAM_VALUE pv;
 112 std::vector<PARAM_VALUE>::const_iterator pvi;
 113 ///////////////////////////
 114 pv.param = "Port";
 115 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 116 if (pvi == s.moduleParams.end())
 117     {
 118     errorStr = "Parameter \'Port\' not found.";
 119     printfd(__FILE__, "Parameter 'Port' not found\n");
 120     return -1;
 121     }
 122 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
 123     {
 124     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
 125     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
 126     return -1;
 127     }
 128 port = p;
 129 ///////////////////////////
 130 pv.param = "Password";
 131 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 132 if (pvi == s.moduleParams.end())
 133     {
 134     errorStr = "Parameter \'Password\' not found.";
 135     printfd(__FILE__, "Parameter 'Password' not found\n");
 136     return -1;
 137     }
 138 password = pvi->value[0];
 139 ///////////////////////////
 140 pv.param = "AuthServices";
 141 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 142 if (pvi != s.moduleParams.end())
 143     {
 144     ParseServices(pvi->value, &authServices);
 145     }
 146 ///////////////////////////
 147 pv.param = "AcctServices";
 148 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
 149 if (pvi != s.moduleParams.end())
 150     {
 151     ParseServices(pvi->value, &acctServices);
 152     }
 153
 154 return 0;
 155 }
 156 //-----------------------------------------------------------------------------
 157 //-----------------------------------------------------------------------------
 158 //-----------------------------------------------------------------------------
 159 RADIUS::RADIUS()
 160     : nonstop(false),
 161       isRunning(false),
 162       users(NULL),
 163       stgSettings(NULL),
 164       store(NULL),
 165       sock(-1)
 166 {
 167 InitEncrypt(&ctx, "");
 168 }
 169 //-----------------------------------------------------------------------------
 170 void RADIUS::SetUsers(USERS * u)
 171 {
 172 users = u;
 173 }
 174 //-----------------------------------------------------------------------------
 175 void RADIUS::SetStgSettings(const SETTINGS * s)
 176 {
 177 stgSettings = s;
 178 }
 179 //-----------------------------------------------------------------------------
 180 void RADIUS::SetSettings(const MODULE_SETTINGS & s)
 181 {
 182 settings = s;
 183 }
 184 //-----------------------------------------------------------------------------
 185 void RADIUS::SetStore(STORE * s)
 186 {
 187 store = s;
 188 }
 189 //-----------------------------------------------------------------------------
 190 int RADIUS::ParseSettings()
 191 {
 192 int ret = radSettings.ParseSettings(settings);
 193 if (ret)
 194     errorStr = radSettings.GetStrError();
 195 return ret;
 196 }
 197 //-----------------------------------------------------------------------------
 198 bool RADIUS::IsRunning()
 199 {
 200 return isRunning;
 201 }
 202 //-----------------------------------------------------------------------------
 203 const std::string RADIUS::GetVersion() const
 204 {
 205 return "RADIUS data access plugin v 0.6";
 206 }
 207 //-----------------------------------------------------------------------------
 208 uint16_t RADIUS::GetStartPosition() const
 209 {
 210 // Start before any authorizers!!!
 211 return 20;
 212 }
 213 //-----------------------------------------------------------------------------
 214 uint16_t RADIUS::GetStopPosition() const
 215 {
 216 return 20;
 217 }
 218 //-----------------------------------------------------------------------------
 219 int RADIUS::PrepareNet()
 220 {
 221 sock = socket(AF_INET, SOCK_DGRAM, 0);
 222
 223 if (sock < 0)
 224     {
 225     errorStr = "Cannot create socket.";
 226     printfd(__FILE__, "Cannot create socket\n");
 227     return -1;
 228     }
 229
 230 struct sockaddr_in inAddr;
 231 inAddr.sin_family = AF_INET;
 232 inAddr.sin_port = htons(radSettings.GetPort());
 233 inAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
 234
 235 if (bind(sock, (struct sockaddr*)&inAddr, sizeof(inAddr)) < 0)
 236     {
 237     errorStr = "RADIUS: Bind failed.";
 238     printfd(__FILE__, "Cannot bind socket\n");
 239     return -1;
 240     }
 241
 242 return 0;
 243 }
 244 //-----------------------------------------------------------------------------
 245 int RADIUS::FinalizeNet()
 246 {
 247 close(sock);
 248 return 0;
 249 }
 250 //-----------------------------------------------------------------------------
 251 int RADIUS::Start()
 252 {
 253 std::string password(radSettings.GetPassword());
 254
 255 authServices = radSettings.GetAuthServices();
 256 acctServices = radSettings.GetAcctServices();
 257
 258 InitEncrypt(&ctx, password);
 259
 260 nonstop = true;
 261
 262 if (PrepareNet())
 263     {
 264     return -1;
 265     }
 266
 267 if (!isRunning)
 268     {
 269     if (pthread_create(&thread, NULL, Run, this))
 270         {
 271         errorStr = "Cannot create thread.";
 272         printfd(__FILE__, "Cannot create thread\n");
 273         return -1;
 274         }
 275     }
 276
 277 errorStr = "";
 278 return 0;
 279 }
 280 //-----------------------------------------------------------------------------
 281 int RADIUS::Stop()
 282 {
 283 if (!IsRunning())
 284     return 0;
 285
 286 nonstop = false;
 287
 288 std::map<std::string, RAD_SESSION>::iterator it;
 289 for (it = sessions.begin(); it != sessions.end(); ++it)
 290     {
 291     USER_PTR ui;
 292     if (users->FindByName(it->second.userName, &ui))
 293         {
 294         ui->Unauthorize(this);
 295         }
 296     }
 297 sessions.erase(sessions.begin(), sessions.end());
 298
 299 FinalizeNet();
 300
 301 if (isRunning)
 302     {
 303     //5 seconds to thread stops itself
 304     for (int i = 0; i < 25 && isRunning; i++)
 305         {
 306         usleep(200000);
 307         }
 308
 309     //after 5 seconds waiting thread still running. now killing it
 310     if (isRunning)
 311         {
 312         if (pthread_kill(thread, SIGINT))
 313             {
 314             errorStr = "Cannot kill thread.";
 315             printfd(__FILE__, "Cannot kill thread\n");
 316             return -1;
 317             }
 318         printfd(__FILE__, "RADIUS::Stop killed Run\n");
 319         }
 320     }
 321
 322 return 0;
 323 }
 324 //-----------------------------------------------------------------------------
 325 void * RADIUS::Run(void * d)
 326 {
 327 RADIUS * rad = (RADIUS *)d;
 328 RAD_PACKET packet;
 329
 330 rad->isRunning = true;
 331
 332 while (rad->nonstop)
 333     {
 334     if (!rad->WaitPackets(rad->sock))
 335         {
 336         continue;
 337         }
 338     struct sockaddr_in outerAddr;
 339     if (rad->RecvData(&packet, &outerAddr))
 340         {
 341         printfd(__FILE__, "RADIUS::Run Error on RecvData\n");
 342         }
 343     else
 344         {
 345         if (rad->ProcessData(&packet))
 346             {
 347             packet.packetType = RAD_REJECT_PACKET;
 348             }
 349         rad->Send(packet, &outerAddr);
 350         }
 351     }
 352
 353 rad->isRunning = false;
 354
 355 return NULL;
 356 }
 357 //-----------------------------------------------------------------------------
 358 int RADIUS::RecvData(RAD_PACKET * packet, struct sockaddr_in * outerAddr)
 359 {
 360     int8_t buf[RAD_MAX_PACKET_LEN];
 361     socklen_t outerAddrLen = sizeof(struct sockaddr_in);
 362     int dataLen = recvfrom(sock, buf, RAD_MAX_PACKET_LEN, 0, reinterpret_cast<struct sockaddr *>(outerAddr), &outerAddrLen);
 363     if (dataLen > 0) {
 364         Decrypt(&ctx, (char *)packet, (const char *)buf, dataLen / 8);
 365     }
 366     if (strncmp((char *)packet->magic, RAD_ID, RAD_MAGIC_LEN))
 367         {
 368         printfd(__FILE__, "RADIUS::RecvData Error magic. Wanted: '%s', got: '%s'\n", RAD_ID, packet->magic);
 369         return -1;
 370         }
 371     return 0;
 372 }
 373 //-----------------------------------------------------------------------------
 374 int RADIUS::Send(const RAD_PACKET & packet, struct sockaddr_in * outerAddr)
 375 {
 376 size_t len = sizeof(RAD_PACKET);
 377 char buf[1032];
 378
 379 Encrypt(&ctx, buf, (char *)&packet, len / 8);
 380 return sendto(sock, buf, len, 0, reinterpret_cast<struct sockaddr *>(outerAddr), sizeof(struct sockaddr_in));
 381 }
 382 //-----------------------------------------------------------------------------
 383 int RADIUS::ProcessData(RAD_PACKET * packet)
 384 {
 385 if (strncmp((const char *)packet->protoVer, "01", 2))
 386     {
 387     printfd(__FILE__, "RADIUS::ProcessData packet.protoVer incorrect\n");
 388     return -1;
 389     }
 390 switch (packet->packetType)
 391     {
 392     case RAD_AUTZ_PACKET:
 393         return ProcessAutzPacket(packet);
 394     case RAD_AUTH_PACKET:
 395         return ProcessAuthPacket(packet);
 396     case RAD_POST_AUTH_PACKET:
 397         return ProcessPostAuthPacket(packet);
 398     case RAD_ACCT_START_PACKET:
 399         return ProcessAcctStartPacket(packet);
 400     case RAD_ACCT_STOP_PACKET:
 401         return ProcessAcctStopPacket(packet);
 402     case RAD_ACCT_UPDATE_PACKET:
 403         return ProcessAcctUpdatePacket(packet);
 404     case RAD_ACCT_OTHER_PACKET:
 405         return ProcessAcctOtherPacket(packet);
 406     default:
 407         printfd(__FILE__, "RADIUS::ProcessData Unsupported packet type: %d\n", packet->packetType);
 408         return -1;
 409     };
 410 return 0;
 411 }
 412 //-----------------------------------------------------------------------------
 413 int RADIUS::ProcessAutzPacket(RAD_PACKET * packet)
 414 {
 415 USER_CONF conf;
 416
 417 if (!IsAllowedService((char *)packet->service))
 418     {
 419     printfd(__FILE__, "RADIUS::ProcessAutzPacket service '%s' is not allowed to authorize\n", packet->service);
 420     packet->packetType = RAD_REJECT_PACKET;
 421     return 0;
 422     }
 423
 424 if (store->RestoreUserConf(&conf, (char *)packet->login))
 425     {
 426     packet->packetType = RAD_REJECT_PACKET;
 427     printfd(__FILE__, "RADIUS::ProcessAutzPacket cannot restore conf for user '%s'\n", packet->login);
 428     return 0;
 429     }
 430
 431 // At this point service can be authorized at least
 432 // So we send a plain-text password
 433
 434 packet->packetType = RAD_ACCEPT_PACKET;
 435 strncpy((char *)packet->password, conf.password.c_str(), RAD_PASSWORD_LEN);
 436
 437 return 0;
 438 }
 439 //-----------------------------------------------------------------------------
 440 int RADIUS::ProcessAuthPacket(RAD_PACKET * packet)
 441 {
 442 USER_PTR ui;
 443
 444 if (!CanAcctService((char *)packet->service))
 445     {
 446
 447     // There are no sense to check for allowed service
 448     // It has allready checked at previous stage (authorization)
 449
 450     printfd(__FILE__, "RADIUS::ProcessAuthPacket service '%s' neednot stargazer authentication\n", (char *)packet->service);
 451     packet->packetType = RAD_ACCEPT_PACKET;
 452     return 0;
 453     }
 454
 455 // At this point we have an accountable service
 456 // All other services got a password if allowed or rejected
 457
 458 if (!FindUser(&ui, (char *)packet->login))
 459     {
 460     packet->packetType = RAD_REJECT_PACKET;
 461     printfd(__FILE__, "RADIUS::ProcessAuthPacket user '%s' not found\n", (char *)packet->login);
 462     return 0;
 463     }
 464
 465 if (ui->IsInetable())
 466     {
 467     packet->packetType = RAD_ACCEPT_PACKET;
 468     }
 469 else
 470     {
 471     packet->packetType = RAD_REJECT_PACKET;
 472     }
 473
 474 packet->packetType = RAD_ACCEPT_PACKET;
 475 return 0;
 476 }
 477 //-----------------------------------------------------------------------------
 478 int RADIUS::ProcessPostAuthPacket(RAD_PACKET * packet)
 479 {
 480 USER_PTR ui;
 481
 482 if (!CanAcctService((char *)packet->service))
 483     {
 484
 485     // There are no sense to check for allowed service
 486     // It has allready checked at previous stage (authorization)
 487
 488     packet->packetType = RAD_ACCEPT_PACKET;
 489     return 0;
 490     }
 491
 492 if (!FindUser(&ui, (char *)packet->login))
 493     {
 494     packet->packetType = RAD_REJECT_PACKET;
 495     printfd(__FILE__, "RADIUS::ProcessPostAuthPacket user '%s' not found\n", (char *)packet->login);
 496     return 0;
 497     }
 498
 499 // I think that only Framed-User services has sense to be accountable
 500 // So we have to supply a Framed-IP
 501
 502 USER_IPS ips = ui->GetProperty().ips;
 503 packet->packetType = RAD_ACCEPT_PACKET;
 504
 505 // Additional checking for Framed-User service
 506
 507 if (!strncmp((char *)packet->service, "Framed-User", RAD_SERVICE_LEN))
 508     packet->ip = ips[0].ip;
 509 else
 510     packet->ip = 0;
 511
 512 return 0;
 513 }
 514 //-----------------------------------------------------------------------------
 515 int RADIUS::ProcessAcctStartPacket(RAD_PACKET * packet)
 516 {
 517 USER_PTR ui;
 518
 519 if (!FindUser(&ui, (char *)packet->login))
 520     {
 521     packet->packetType = RAD_REJECT_PACKET;
 522     printfd(__FILE__, "RADIUS::ProcessAcctStartPacket user '%s' not found\n", (char *)packet->login);
 523     return 0;
 524     }
 525
 526 // At this point we have to unauthorize user only if it is an accountable service
 527
 528 if (CanAcctService((char *)packet->service))
 529     {
 530     if (sessions.find((const char *)packet->sessid) != sessions.end())
 531         {
 532         printfd(__FILE__, "RADIUS::ProcessAcctStartPacket session already started!\n");
 533         packet->packetType = RAD_REJECT_PACKET;
 534         return -1;
 535         }
 536     USER_IPS ips = ui->GetProperty().ips;
 537     if (ui->Authorize(ips[0].ip, 0xffFFffFF, this))
 538         {
 539         printfd(__FILE__, "RADIUS::ProcessAcctStartPacket cannot authorize user '%s'\n", packet->login);
 540         packet->packetType = RAD_REJECT_PACKET;
 541         return -1;
 542         }
 543     sessions[(const char *)packet->sessid].userName = (const char *)packet->login;
 544     sessions[(const char *)packet->sessid].serviceType = (const char *)packet->service;
 545     for_each(sessions.begin(), sessions.end(), SPrinter());
 546     }
 547 else
 548     {
 549     printfd(__FILE__, "RADIUS::ProcessAcctStartPacket service '%s' can not be accounted\n", (char *)packet->service);
 550     }
 551
 552 packet->packetType = RAD_ACCEPT_PACKET;
 553 return 0;
 554 }
 555 //-----------------------------------------------------------------------------
 556 int RADIUS::ProcessAcctStopPacket(RAD_PACKET * packet)
 557 {
 558 std::map<std::string, RAD_SESSION>::iterator sid;
 559
 560 if ((sid = sessions.find((const char *)packet->sessid)) == sessions.end())
 561     {
 562     printfd(__FILE__, "RADIUS::ProcessAcctStopPacket session had not started yet\n");
 563     packet->packetType = RAD_REJECT_PACKET;
 564     return -1;
 565     }
 566
 567 USER_PTR ui;
 568
 569 if (!FindUser(&ui, sid->second.userName))
 570     {
 571     packet->packetType = RAD_REJECT_PACKET;
 572     printfd(__FILE__, "RADIUS::ProcessPostAuthPacket user '%s' not found\n", sid->second.userName.c_str());
 573     return 0;
 574     }
 575
 576 sessions.erase(sid);
 577
 578 ui->Unauthorize(this);
 579
 580 packet->packetType = RAD_ACCEPT_PACKET;
 581 return 0;
 582 }
 583 //-----------------------------------------------------------------------------
 584 int RADIUS::ProcessAcctUpdatePacket(RAD_PACKET * packet)
 585 {
 586 // Fake. May be use it later
 587 packet->packetType = RAD_ACCEPT_PACKET;
 588 return 0;
 589 }
 590 //-----------------------------------------------------------------------------
 591 int RADIUS::ProcessAcctOtherPacket(RAD_PACKET * packet)
 592 {
 593 // Fake. May be use it later
 594 packet->packetType = RAD_ACCEPT_PACKET;
 595 return 0;
 596 }
 597 //-----------------------------------------------------------------------------
 598 void RADIUS::PrintServices(const std::list<std::string> & svcs)
 599 {
 600 for_each(svcs.begin(), svcs.end(), Printer());
 601 }
 602 //-----------------------------------------------------------------------------
 603 bool RADIUS::FindUser(USER_PTR * ui, const std::string & login) const
 604 {
 605 if (users->FindByName(login, ui))
 606     {
 607     return false;
 608     }
 609 return true;
 610 }
 611 //-----------------------------------------------------------------------------
 612 bool RADIUS::CanAuthService(const std::string & svc) const
 613 {
 614 return find(authServices.begin(), authServices.end(), svc) != authServices.end();
 615 }
 616 //-----------------------------------------------------------------------------
 617 bool RADIUS::CanAcctService(const std::string & svc) const
 618 {
 619 return find(acctServices.begin(), acctServices.end(), svc) != acctServices.end();
 620 }
 621 //-----------------------------------------------------------------------------
 622 bool RADIUS::IsAllowedService(const std::string & svc) const
 623 {
 624 return CanAuthService(svc) || CanAcctService(svc);
 625 }
 626 //-----------------------------------------------------------------------------
 627 bool RADIUS::WaitPackets(int sd) const
 628 {
 629 fd_set rfds;
 630 FD_ZERO(&rfds);
 631 FD_SET(sd, &rfds);
 632
 633 struct timeval tv;
 634 tv.tv_sec = 0;
 635 tv.tv_usec = 500000;
 636
 637 int res = select(sd + 1, &rfds, NULL, NULL, &tv);
 638 if (res == -1) // Error
 639     {
 640     if (errno != EINTR)
 641         {
 642         printfd(__FILE__, "Error on select: '%s'\n", strerror(errno));
 643         }
 644     return false;
 645     }
 646
 647 if (res == 0) // Timeout
 648     {
 649     return false;
 650     }
 651
 652 return true;
 653 }
 654 //-----------------------------------------------------------------------------
 655 inline
 656 void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password)
 657 {
 658 unsigned char keyL[RAD_PASSWORD_LEN];  // Пароль для шифровки
 659 memset(keyL, 0, RAD_PASSWORD_LEN);
 660 strncpy((char *)keyL, password.c_str(), RAD_PASSWORD_LEN);
 661 Blowfish_Init(ctx, keyL, RAD_PASSWORD_LEN);
 662 }
 663 //-----------------------------------------------------------------------------
 664 inline
 665 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
 666 {
 667 // len8 - длина в 8-ми байтовых блоках
 668 if (dst != src)
 669     memcpy(dst, src, len8 * 8);
 670
 671 for (int i = 0; i < len8; i++)
 672     Blowfish_Encrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
 673 }
 674 //-----------------------------------------------------------------------------
 675 inline
 676 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
 677 {
 678 // len8 - длина в 8-ми байтовых блоках
 679 if (dst != src)
 680     memcpy(dst, src, len8 * 8);
 681
 682 for (int i = 0; i < len8; i++)
 683     Blowfish_Decrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
 684 }